Glossary

Event sourcing comes with its own vocabulary, and the Cratis stack adds a few terms of its own. This page gives a short definition of each term across the stack, so the same word means the same thing on every page. Where a term has a fuller explanation, the name links to it. The products keep their own, more detailed glossaries: Chronicle, Arc, and Screenplay.

Event sourcing

These are the core ideas behind Chronicle. The Concepts section explains how they fit together.

Term	Definition
Event	A fact — something that happened, named in the past tense (AccountOpened). Immutable and single-purpose. By convention an event has no nullable properties (Chronicle’s analyzers warn about them); an optional value usually means you need a second event.
Event type	The schema and identity of an event — its shape and name.
Event source	The thing an event happened to, identified by an id (an account, a book).
Event source definition	A declared kind of event source (an account) with its named event streams and the dimensions that guard appends to each. The typed way to say where events go.
Event stream	A named part of an event source’s history, such as an account’s monthly transactions. Identified by a stream type and a stream id.
Event sequence	An ordered, append-only stream of events you can subscribe to. The event log is the primary one — your source of truth.
Sequence number	An event’s position within a sequence.
Event store	The database that holds event sequences.
Event sourcing	Storing state as the full history of events, deriving current state by replaying them. See when to use it.
Namespace	A partition of an event store, used for multi-tenancy.
Tenant	An isolated set of data for one customer — see namespaces.
Identity	Who or what caused an event.
Correlation	Links events that belong to the same logical operation.
Causation	The chain of steps that led to an event, such as the root process and the command that appended it. With Arc, the command’s name and property values are recorded in the chain, permanently.
Tags	Labels on events for filtering and correlation — see also event metadata tags.
Aggregate	A consistency boundary that encapsulates behavior and produces events.
Constraint	A rule, such as uniqueness, that Chronicle checks when an event is appended and rejects the append if it fails.
Dynamic consistency boundary	Enforcing a rule that depends on current state under concurrency, by checking the state the decision was based on when the events are appended. Chronicle supports DCB-style decision models and append conditions; each event belongs to one event source. See keeping decisions correct.
Concurrency scope	The condition on one append: a position in the event log and a filter (event types, event source, stream). The kernel rejects the append if a matching event was written after the position. See concurrency.
Append condition	What Chronicle checks together with an append: one or more concurrency scopes. Also called a guard when it comes from a read. See how guards are derived.
Decision read	A read of a read model that notes the log position before it folds, so the state you decide on becomes an append condition.
Read protection	Refusing reads that cannot guard a decision. In Chronicle it is the API that enforces this inside one unit of work. In Arc it is a mode, Off, Measure or On, that turns the API on for your commands. See keeping decisions correct.
Protected read	A read under read protection On that is read fresh and guarded, such as a read-model parameter on a command.
Advisory read	A read that is allowed but guards nothing, because a stale value is acceptable. In Arc it is marked [Unprotected("why")].
Measure	The Arc read protection mode between Off and On. Nothing changes for callers, and Arc records what On would do, so you can fix refused reads before turning it on.
Per-stream read model	A read model declared with [EventStream<TSource>(stream)] that folds one stream of an event source, such as one account’s withdrawals in one month.
Stream decision	A command reads the raw events of one stream through IStreamReads and returns StreamDecision.Append(...), which guards that stream at the tail it read.
Subject	The person or entity whose personal data an event contains. PII is encrypted under a key per subject, which defaults to the event source id.
PII	Personal data marked with [PII], encrypted at append time so it can be erased by deleting the subject’s key. See event sourcing and GDPR.

Turning events into state

How events become the things you read and the actions you take.

Term	Definition
Observer	Anything that watches events and acts — a projection, reducer, or reactor.
Projection	Builds a read model by mapping events declaratively.
Reducer	Builds a read model by folding events imperatively.
Reactor	Produces side effects (notifications, calls to other systems) in response to events. An event can be delivered to a reactor more than once, so side effects should be safe to repeat.
Replay	Running an observer over events it has already processed, for example to rebuild a read model. Replay re-delivers events to reactors unless the handler is marked [OnceOnly].
Read model	A queryable view shaped for one screen or question, built from events.
Changeset	The set of changes an observer applies for a single event.
Eventual consistency	A read model that catches up shortly after an event is appended — the default.
Immediate consistency	A read model updated synchronously, before the append returns — for reads you must get right now.

Full-stack: CQRS and the frontend

The terms Arc and Components add on top of Chronicle.

Term	Definition
Command	An intent to change state — a record with a Handle() method. With Arc and Chronicle, events returned from Handle() are appended; a command can also return a response or nothing.
Query	A read of data, exposed to the frontend as a typed proxy.
Observable query	A query that holds a live connection and pushes new results when the data changes.
CQRS	Command Query Responsibility Segregation — separating the write side (commands) from the read side (queries). See it in C#, TypeScript, and Kotlin and Java.
Proxy generation	Arc emitting a typed TypeScript client from your C# commands and queries at build time.
Concept	A strongly-typed wrapper around a primitive (AccountId over Guid) so the compiler catches mix-ups.
Agentic development	Letting AI coding agents design, change and operate a system whose state is an event log and whose behavior is checked by executable specifications.
Vertical slice	Everything for one behavior — command, events, projection, UI, specs — kept together in one folder.
Event modeling	Designing a system as one timeline of screens, commands, events and read models before writing code.
Spec-driven development	Writing the event model and its Given/When/Then specifications first, then checking code, written by people or agents, against them.

New to all this? Start with Why developers choose Cratis, then the Chronicle tutorial.