Components (Release v4.19.0): Toolbar and ActionMenubar move focus between tools with the arrow keys and Home/End, following the toolbar’s orientation and reading direction. Every tool keeps its own Tab stop, so Tab works as before. Keys inside inputs, sliders, selects and other widgets in a toolbar keep their native behavior, and a handler that calls preventDefault still wins. The new focusMode prop (ToolbarFocusMode) is Arrows by default; use None to keep the previous behavior. A mode with a single Tab stop for the whole toolbar is planned in #353. (#328)
Components (Release v4.19.0): The PivotViewer card viewport is a keyboard-focusable, named scroll region. Arrow and Page keys scroll overflowing cards, and Tab moves on to the next control. Use labels.viewport to localize its default name, “Card area.” Canvas cards themselves are still not keyboard-selectable. (#349)
Components (Release v4.19.0): CratisComponentsProvidermessages.filter localizes the filter panel’s accessible name (label) and its search inputs’ names (searchAriaLabel) for the whole application. An explicit prop still wins. For search inputs, the placeholder is used when the provider message is not set, so existing names do not change. messages.filter.label also names the PivotViewer Filters button when labels.filters is not set. The CratisFilterMessages type is exported. (#347)
Chronicle (Release v19.15.0): Structured named tags: an event can carry NamedTag values, each a TagName and a string value, next to its existing plain tags. Append them with AppendWithNamedTags, AppendManyWithNamedTags and AddEventWithNamedTags on IEventSequence, ITransactionalEventSequence and IUnitOfWork; they are available on EventContext.NamedTags (#3953)
Chronicle (Release v19.15.0): Query events and sequence histograms by named tags through the kernel gRPC API (IEventSequences.QueryEventsWithNamedTags and SequenceHistogramWithNamedTags). Criteria are combined with OR across criteria and AND with the other query dimensions; each criterion matches a name and value on the same tag, compares ordinally, and treats a missing value list as “any value” (#3953)
Chronicle (Release v19.15.0): Named tags are stored and indexed on MongoDB, SQL (SQLite, PostgreSQL and SQL Server) and in-memory storage. An exact duplicate name and value pair on one event is kept once. Named-tag batch appends keep per-event causation and migrated generations (#3953)
Chronicle (Release v19.15.0): Upgrade servers before clients: a new client appending named tags to an older server gets UNIMPLEMENTED instead of silently losing the tags.
Chronicle (Release v19.15.0): SQL storage reserves the per-namespace table __cratis_named_tags. If a table with that name already exists, event-sequence operations in that namespace fail with NamedTagsTableCollision until it is renamed.
Chronicle (Release v19.15.0): Tag names and values are stored in plaintext and indexed. Never put personal data in tags.
Chronicle (Release v19.15.0): The Workbench HTTP proxies for the named-tag queries are generated but cannot carry structured criteria yet; use the gRPC API (#4277).
cli (Release v3.21.0): Cratis AI update hint. In a repository with the Cratis AI corpus installed (.cratis/ai.json and .cratis/ai.manifest.json), an interactive command may end with ↑ Cratis AI update available: 12 new commits since cc9c631 - run 'cratis ai update'. The hint appears only when the installed commit is behind the latest commit on Cratis/AI’s default branch, so a corpus installed from a local checkout or another branch never triggers it. The answer is cached per installed commit next to the CLI version check and rechecked hourly. The hint is skipped when output is redirected, in AI agent environments and completions, while running ai install/ai update/ai uninstall, and when CRATIS_NO_UPDATE_CHECK is set (#197).
cli (Release v3.21.0): cratis render sends Screenplay’s typed-context descriptors to Stage, so generated code can use typed contexts (#192).
Arc (Release v22.31.0): A named Arc authorization policy can opt in to being evaluated for unauthenticated callers: AddArcAuthorizationPolicy<TPolicy>(name, evaluatesAnonymous: true). The policy then receives an empty, unauthenticated principal and decides whether to allow the guest. This works the same with Arc’s [Authorize] and ASP.NET Core’s [Authorize(Policy = ...)], for commands, queries and observable queries. (#2761)
Arc (Release v22.31.0): AddArcAnonymousAspNetAuthorizationPolicy(name) gives the same opt-in to a policy registered through ASP.NET Core. It is checked at startup: the name must resolve to exactly one ASP.NET Core policy that doesn’t require an authenticated user. Otherwise startup fails with InvalidAuthorizationConfiguration. (#2761)
Stage (Release v4.21.0): Render Screenplay ESM v3 reducers with verified portable C# bodies as Chronicle reducers and typed context adapters. Supported deterministic, finite operations are admitted explicitly; unsupported or mismatched bodies fail with actionable diagnostics.
Stage (Release v4.21.0): Generate read-model and command specifications for reducer-backed models, including collection event expectations and deletion. The Billing payment reducer is an executable example.
Stage (Release v4.21.0): Guard every non-null reducer output so its identifier matches the event-source key; mismatches fail rather than silently routing a keyed query to unrelated state.
Orleans (Release v1.12.1): A packed-consumer check that restores and builds Cratis.Orleans for .NET 8, 9 and 10 and fails when consumers would resolve mixed Orleans versions. It runs on pull requests, in the daily package update, and before a release is cut.
Arc.TypeScript (v0.43.0): ChronicleCommandScenario and ChronicleQueryScenario evaluate supported flat projections in-process through ReadModelScenario from @cratis/chronicle 6.19.0, so given.forEventSource(...).events(...) now populates projection-backed read models as well as reducer-backed ones. See Test Chronicle commands and queries for the boundary.
Arc.TypeScript (v0.43.0): A pinned instance wins over history, and a reducer wins over a projection. Projection seeds replay in the order they were given across event sources.
Arc.TypeScript (v0.43.0): A projection outside the supported boundary throws the SDK’s UnsupportedProjectionOperation unchanged; test it with ChronicleKernelScenario.
Chronicle.TypeScript (Release v6.22.0): ReactorScenario in @cratis/chronicle/testing delivers given and when events in order using production handler dispatch and artifact activation. An artifactActivator receives per-event run metadata and complete() is called after delivery, including on failure.
Chronicle.TypeScript (Release v6.22.0): Inspect returned events through produced, sideEffects, results, shouldHaveProduced, and shouldNotHaveProduced. Handler failures reject the delivery and prevent further deliveries.
Chronicle.TypeScript (Release v6.22.0): Unsupported replay, redelivery, command recording, tag-filtered reactors, self-subscribed appends, store/read-model/event-log services, and waitForCompletion reject with UnsupportedReactorOperation or UnsupportedEventSequenceOperation, directing tests to a kernel-backed scenario. Unsupported calls fail delivery even when caught by a handler.
Orleans (Release v1.12.0): Cratis.Orleans.Chronicle package with EventSourcedStateMachine<TModel>: an Orleans state machine whose model is a Chronicle read model derived from events. It reads through IEventStore.ReadModels, never writes, and needs no [StorageProvider] (#34)
Orleans (Release v1.12.0): DefineProjection(IProjectionBuilderFor<TModel>) for declarative projections; model-bound projections on TModel also work. Projections are registered through Chronicle’s explicit registration API (#34)
Orleans (Release v1.12.0): DefineTransitions(IStateMachineTransitions<TModel>) with .On<TEvent>().TransitionTo<TState>() and optional model guards. Definitions are inspected at startup (#34)
Orleans (Release v1.12.0): One fluent Chronicle reactor per state machine, subscribed to the union of the projection’s and the transitions’ event types. Each delivered event refreshes the grain’s model, calls OnModelChanged(previous, current, context), then applies matching transitions (#34)
Orleans (Release v1.12.0): Grain keys {eventStore}/{namespace}/{eventSourceId} isolate tenants. IGrainFactory.GetEventSourcedStateMachine<T>(...) resolves a grain; ResolveState(model) derives the current state from the model on activation, so no state is persisted (#34)
Orleans (Release v1.12.0): AddEventSourcedStateMachines() for IServiceCollection / ISiloBuilder (#34)
Chronicle (Release v19.14.0): IProjections.Register<TReadModel>(define, id) registers a read model together with a declarative projection defined through the same IProjectionBuilderFor<TReadModel> an IProjectionFor<T> uses, without assembly discovery. The read model behaves like any other through IReadModels, including passive (on-demand) read models (#4287)
Chronicle (Release v19.14.0): IProjections.Register<TReadModel>() registers the model-bound projection of a read model that discovery did not find (#4287)
Chronicle (Release v19.14.0): IReactors.Define(id, reactor => ...) and IReactors.Register(id, reactor => ...) declare reactors fluently with typed On<TEvent> handlers — (TEvent), (TEvent, EventContext) and their Task-returning forms — and a catch-all Subscribe((object, EventContext) => ...). IReactorDefinition exposes the reactor id, event types and whether it subscribes to all events (#4288)
Chronicle (Release v19.14.0): ChronicleOptions.ExplicitArtifacts registers explicit projections, read models and fluent reactors before the client connects; they are included in every registration pass, including after a reconnect (#4287, #4288)
Orleans (Release v1.11.0): Cratis.Orleans.StateMachines: the generic Orleans state machine, extracted from Chronicle with the same behavior — StateMachine<TStoredState>, State<TStoredState>, IState<TStoredState>, IStateMachine<TStoredState>, NoOpState, StateMachineState, allowed transitions, OnEnter/OnLeave, and transitions scheduled while entering (#33)
Orleans (Release v1.11.0): A protected StateMachine(IStorage<TStoredState>) constructor, so a derived state machine can supply its own storage without a [StorageProvider] attribute (#33)
Orleans (Release v1.11.0): ResolveActivationState() lets a derived state machine decide which state to enter on activation, and the protected CanTransitionTo(Type) / TransitionTo(Type) allow transitions by type while still honoring each state’s rules (#33)
Arc.TypeScript (v0.42.0): The proxy generator can write proxies into the backend slice folders. When the output is the artifacts folder, one of its ancestors, or a nested folder containing backend artifacts, the .proxy suffix is required, no barrels are written, and watch mode regenerates on backend edits. The generator only overwrites or deletes files it generated, and never analyzes generated, .proxy, .tsx or spec files as backend artifacts.
Arc.TypeScript (v0.42.0): The Library sample keeps every slice together, uses @cratis/components (DataPage for the author listing, CommandDialog for registration) and runs frontend specs under jsdom beside the backend specs in yarn test. The Tasks sample generates its proxies in place too.
Arc.TypeScript (v0.42.0): CI fails when committed proxies are stale, and when the Library web bundle contains decorator syntax a browser cannot parse.
Chronicle.TypeScript (Release v6.21.0): EventScenario supports both appendMany overloads. Batches append atomically in input order and return one result per event. The mixed-source overload uses the production client’s per-entry precedence for routing, subject, and occurrence, and merges per-entry and shared tags.
Chronicle.TypeScript (Release v6.21.0): given.forEventSource(id).events(...events) accepts multiple setup events as sequential single appends; if any setup event is rejected, none from that call are committed. when.forEventSource(id).events(...events) appends one atomic batch and returns a result for each event.
Chronicle.TypeScript (Release v6.21.0): The in-process sequence supports source, event-type, and route read filters, plus append notifications for single and batch appends. Constraints remain unsupported and are rejected rather than simulated.
Chronicle.TypeScript (Release v6.21.0): Committed fixtures from the pinned Chronicle kernel verify batch ordering, metadata, causation, read filters, and rejection behavior.
Components (Release v4.18.0): --cratis-canvas-minimap-grid-color and --cratis-canvas-minimap-item-color theme the Canvas minimap dot grid and items that have no color of their own. Both fall back to the current colors, so the minimap looks the same until you set them.
Components (Release v4.17.0): controlsIcons on Canvas (icons on CanvasControls) replaces any of the minimap, zoom-out, zoom-in and help glyphs with your own icons. Unset fields keep the built-in icons, and the accessible names still come from controlsLabels.
Components (Release v4.17.0): controlsFollowViewportInsets on Canvas (followViewportInsets on CanvasControls) turns off the offset by --canvas-viewport-left/--canvas-viewport-right, for hosts that already move the canvas by that inset. It defaults to true, so existing canvases are unchanged.
Components (Release v4.17.0): The --canvas-viewport-left and --canvas-viewport-right custom properties the controls read are now documented.
Screenplay (Release v4.43.0): Publish a slim Cratis.Screenplay.Contexts package containing the code-body context family without compiler dependencies. Cratis.Screenplay references it and forwards every moved public type, preserving existing binaries. Closes #283.
Chronicle.TypeScript (Release v6.20.0): Add EventScenario to @cratis/chronicle/testing for kernel-free, scenario-local single-event appends. given seeds accepted events, when appends one event, and results and appendedEvents expose the act results and accepted history. The scenario supports global sequence allocation, hasEventsFor, next and tail positions, source/type reads, and inclusive reads from a sequence number within its documented input boundary.
Chronicle.TypeScript (Release v6.20.0): Check the supported append metadata, results, and reads against committed fixtures generated by the pinned Chronicle 19.8.1 kernel oracle. Add an EventScenario guide and compiled documentation snippets.
Chronicle (Release v19.13.0): IUnitOfWork.HasEnrolledDecisionReads reports whether a protected decision read was successfully enrolled, including after commit, rollback or disposal. Command owners can use it to refuse an unguarded returned-event fallback. Existing custom units of work default to false; no decision tokens or sequence numbers are exposed.
Chronicle (Release v19.13.0): Release solution build (zero warnings), all non-integration specifications, client packaging, formatting and markdown validation passed.
Chronicle (Release v19.13.0): Local MongoDB integration could not start: Docker Desktop LinuxKit kernel 7.0.12 is incompatible with the MongoDB image. A bounded reproduction failed before test assertions; integration CI on GitHub must pass before merge.
Arc.TypeScript (v0.41.0): Experimental DrizzleObservation.PostgreSQLNotify mode: withDrizzle({ observation: { mode: DrizzleObservation.PostgreSQLNotify, listener } }) listens for PostgreSQL NOTIFY on the fixed arc_changes channel through one dedicated connection per tenant, and re-reads observed tables after each committed change. The first read of an observation happens only after LISTEN is acknowledged and the table’s trigger is validated.
Arc.TypeScript (v0.41.0): postgresqlChangeTrigger(table, { schema? }) returns the trigger SQL to add to a drizzle-kit migration. Arc never runs DDL at runtime; a missing, disabled or incompatible trigger fails the observation before any rows are read.
Arc.TypeScript (v0.41.0): nodePostgresListener(...) adapts a dedicated node-postgres Client as the listener connection. No pg runtime import is added to the package root.
Arc.TypeScript (v0.41.0): A PostgreSQL-only mode for Source/Drizzle/run-integration.sh and a CI job running the PostgreSQL integration specs.
Components (Release v4.16.0): confirmBeforeExecute on CommandDialog, StepperCommandDialog, and CommandStepper asks a question after validation and onBeforeExecute, and before the command runs. Only true executes. Any other answer leaves the dialog or stepper open without running the command. If the command values change while the question is open, the command is not executed and you confirm again. Stepper fields are disabled until the confirmed submission settles. Without the prop, command execution is unchanged. The ConfirmBeforeExecute type is exported. (#317)
Components (Release v4.16.0): ChatSidebar accepts topicsStatus and messagesStatus (the new ChatStatus enum), and ChatSidebarForObservableQueries sets them from its queries. The topic list and conversation show loading, failure, and unauthorized text from new labels keys, and never show server exception text. A failure keeps what is already shown and adds an alert above it. Unauthorized replaces the content and disables the composer and the New topic button. (#327)
Components (Release v4.16.0): PivotViewerlabels makes the toolbar text, the item count, and the filter panel’s name and search placeholder localizable. The defaults are unchanged. loadingLabel still takes precedence over labels.loading. (#334)
Components (Release v4.16.0): PivotViewerlabels.searchGroup names the search box of each option group in the filter panel. It receives the group’s label and defaults to Search <group>, so each group search now has its own accessible name. (#334)
Components (Release v4.16.0): FilterPanel aria-label and searchAriaLabel, FilterDefinitionsearchAriaLabel and autoFocus, and CheckboxListFiltersearchAriaLabel and autoFocusSearch. (#328, #244)
Components (Release v4.16.0): A DatePickerInput reference page, and Common and Dialogs landing pages that help you choose a control. (#260)
Chronicle (Release v19.12.0): The .NET client’s generated JSON schemas give inline object types a title with the type name. A declaration generated from a fluent composite-key projection (for example in the Workbench) can then name the key type and recompile. The fluent CompositeKeyBuilder still emits untyped expressions, so older kernels are unaffected (#4253)
Chronicle (Release v19.12.0): The ASP.NET Core causation middleware records the matched route template in a new routeTemplate causation property, alongside the existing request path (#4260)
Arc (Release v22.30.0): IFallbackAuthorizationEvaluator supplies baseline authorization requirements for commands and queries that declare none of their own. It is consulted only when neither the method nor the type has an explicit declaration, so [AllowAnonymous] members are no longer ambiguous with a baseline. Commands consult only the Type overload. MVC controller actions, including direct HTTP and WebSocket requests to controller-based queries, stay on ASP.NET Core authorization: use AuthorizationOptions.FallbackPolicy there (#2751)
Arc (Release v22.30.0): ReceivedAt on CommandContext, QueryContext and AuthorizationPolicyContext, plus an injectable IOperationContextAccessor, expose the time Arc received the operation. It is captured with TimeProvider at Arc’s transport dispatch, before binding, or at pipeline entry for programmatic calls, and per subscribe operation for streams. It is Arc’s receipt time, not network arrival. ReceivedAt takes part in record equality, so contexts from different receipts compare unequal (#2767)
Arc (Release v22.30.0): Query filters can set SubscriptionScope on the query context. Arc snapshots it after filtering and before the query runs, and gives each emission guard an independent copy, so guards can base decisions on membership that the arguments don’t carry. Only state that Arc’s JSON options serialize is kept, and a scope that cannot be represented is rejected with InvalidSubscriptionScope. The scope is always null for controller-based observable queries (#2768)
Chronicle.TypeScript (Release v6.19.0): ReadModelScenario now builds projection-backed read models in-process when no reducer applies. It compiles the same model-bound or declarative definition used at registration, validates the whole definition before replay, and then replays the given events: root fromEvent/.from() keyed by the event source ID, setFrom and schema-based AutoMap for scalar properties, $eventSourceId, supported $eventContext(...) paths, $value(...), $null, removedWith and initial values. See Test read models without a kernel for the full capability table.
Chronicle.TypeScript (Release v6.19.0): UnsupportedProjectionOperation, exported from @cratis/chronicle/testing. Anything the in-process evaluator does not support (arithmetic such as @count/@increment, children, joins, nested projections, compliance metadata, and other listed cases) raises this error when the scenario is created, before any event is replayed, instead of producing a result the kernel might not.
Chronicle.TypeScript (Release v6.19.0): Kernel projection fixtures in Source/testing/projections/fixtures/, produced by the projection oracle against the pinned Chronicle kernel and compared step by step with the in-process results (yarn oracle:check).
Arc.TypeScript (v0.40.0): ArcServer.runInScope(scope, callback, options?) runs a callback inside an existing service scope, with currentServices() and currentContext() set as they are for a request. Only the correlation ID and an extra abort signal can be supplied (RunInScopeOptions); tenant, principal, transport and severity come from the scope. Only scopes created with server.services.createScope(context) can be borrowed; Arc’s own request, query and observable-query scopes cannot. It rejects scopes from another server, singleton, closed or fabricated scopes, and scopes whose principal is not plain data. It is a trusted host API, not an authorization mechanism: commands still go through the normal pipeline.
Chronicle (Release v19.11.0): Register a .NET reactor at runtime by stable ID, explicit event types and generations, and an awaited delegate that receives the event context, the JSON content and the generational content map. Unregister it by ID; the observer keeps its stored position. Tags and filters are not yet configurable on delegate reactors (#4196)
Chronicle (Release v19.11.0): Reactor side-effect handlers can claim synchronous return types with CanHandleReturnType(Type), including a declared IEnumerable<T>. Existing handlers stay compatible (#4121)
Chronicle (Release v19.11.0): IReactors.RetryFailedPartitionFor<TReactor>(partition) retries a reactor’s failed partition from the .NET client and returns a ReactorPartitionRetryOutcome (#3909)
Chronicle (Release v19.11.0): Batch event payloads accept an optional per-event causation field. Older kernels ignore it and store only the ambient chain (#4179)
Chronicle (Release v19.11.0): Append results expose the event types the operation wrote, including for batch appends (#4132)
Chronicle.TypeScript (Release v6.18.0): usingKeyFromContext(...) and usingParentKeyFromContext(...) on declarative .addChild(...), as in Chronicle for .NET, so a child can be keyed from the event context. The context path is validated when the projection is registered.
Arc (Release v22.29.0): JavaScript RuleBuilder.withSeverity and PropertyRule.withSeverity APIs for explicit per-rule validation severity in generated command validators.
Arc (Release v22.28.0): EF Core Observe, ObserveSingle and ObserveById accept ignoreQueryContext: true for auxiliary sources in composed observable queries. Opted-in sources read their full filtered results without client paging or sorting and do not update TotalItems; the primary observation keeps its paging, sorting and count. Existing composed queries must opt in on their auxiliary observations to get this fix, as with the MongoDB overloads in v22.27.0 (#2804)
Arc (Release v22.28.0): AuthorizationPrincipalScope is public, so a query or command pipeline can be composed without AddCratisArc. The query pipeline guide shows the registrations it needs (#2753)
Chronicle.TypeScript (Release v6.17.0): ActivatedArtifact.run(callback, invocation) now receives an ArtifactInvocationContext for every call: the handled event’s EventContext and handler name, or the replay notification. A host can then run each reactor or reducer invocation in a context that matches that event, for example with its correlation ID.
Chronicle.TypeScript (Release v6.17.0): ActivatedArtifact.complete() is an optional hook called once per activation after its batch has been processed, also when processing failed, and before the delivery is acknowledged. If it rejects, the delivery fails with ArtifactCompletionFailed, which keeps a processing error if there was one; dispose() still runs afterwards. A host can use it to fail a delivery whose resources could not be released cleanly.
Chronicle (Release v19.10.0): A join in a projection declaration can set its own automap or no automap, which overrides the projection’s setting. The setting is stored with the definition, and applies to live join events and to backfill. Older clients and stored definitions keep inheriting the projection’s setting. The fluent .NET JoinBuilder and generated client code don’t express it yet.
Chronicle (Release v19.10.0): Joins inside a nested object are wired: joined values are set on the nested object, both when the join event arrives and through backfill.
Stage (Release v4.20.0): Stage renders more of the executable model onto Cratis now that the upstream fixes are released:
Stage (Release v4.20.0): projection literal mappings in from blocks, using only literals Chronicle’s fluent value expression can carry exactly;
Stage (Release v4.20.0): $context.occurred on produced events, with one timestamp for the payload and the event’s occurrence;
Stage (Release v4.20.0): contract and production tags that aren’t duplicated. This is part of #117.
Stage (Release v4.20.0): Validation rules and command requirements with warning or information severity reject the command, using Arc’s [BlockOnValidationSeverity]. (#116)
Stage (Release v4.20.0): Specifications for protected queries run through Arc’s query pipeline, including denials. They are admitted only when every seeded event comes from the queried key.
Stage (Release v4.20.0): The semantic runtime rebuilds its state from stored events on restart through Screenplay’s EstablishWorld. It refuses to start on a history it can’t reproduce.
Chronicle.TypeScript (Release v6.16.0): Reactor handlers receive a third argument, services, with the eventStore and readModels of the event store and namespace the reactor observes, plus the delivery’s abort signal. A handler can now append explicitly and check the AppendResult, or look up a read model before acting, as reactors in Chronicle for .NET can through injected services.
Chronicle.TypeScript (Release v6.16.0): ChronicleOptions.artifactActivator lets an application or framework construct reactors and reducers, for example from a dependency injection container, like ClientArtifactsActivator in .NET. It returns an ActivatedArtifact with the instance and optional run and dispose hooks. With an activator, an artifact is activated once per delivered batch (and separately for replay notifications); run wraps each handler call and its returned events, and dispose runs when the batch is done. Activation failures fail the partition like handler failures; cleanup failures are logged.
Chronicle.TypeScript (Release v6.16.0): ClientArtifactsActivator, ActivatedArtifact, ArtifactActivationContext, ReactorServices and ReplayState are exported from the package root.
Arc (Release v22.27.0): MongoDB Observe, ObserveSingle, and ObserveById accept ignoreQueryContext: true for auxiliary sources in composed observable queries. Opted-in sources read their full filtered results without client paging or sorting and do not update TotalItems; the primary observation keeps its paging, sorting and filtered count. Existing composed queries must opt in on their auxiliary observations to get this fix; the existing overloads remain available (#2756)
Chronicle.TypeScript (Release v6.15.0): @noAutoMap now works on model-bound child and nested types, as in Chronicle for .NET. A child or nested definition stops auto-mapping event properties when its own type, or the type that declares it, carries @noAutoMap. The policy applies to that type’s direct child and nested definitions and doesn’t cascade further.
Chronicle.TypeScript (Release v6.15.0): @noAutoMap on an individual property of a child or nested type now excludes that property from auto-mapping. Previously it was ignored.
Arc.TypeScript (v0.39.0): Paired conformance checks against Arc for .NET 22.23.0 for commands whose handlers return OneOf/Result alternatives: a DTO or primitive answers 200 with it as response, a validation branch answers 400, a denial 403, a tuple’s validation result replaces its response, and no discriminator is added to the wire. An arbitrary Result error DTO in .NET is an ordinary 200 response; in TypeScript, return it with response(...) to get the same result, or use rejected(...)/denied(...) for failures. The suite now runs 279 checks.
Chronicle (Release v19.9.0): Decision reads: IDecisionReads.Get<T>(key) returns a read model instance (or its absence) with an opaque guard, and the unit of work’s commit is rejected if an event that could change what was read has been appended since. Developers never handle sequence numbers. Admitted read models are projections keyed on the event source without joins, children, custom keys or all; everything else is refused with a typed reason. Text keys and canonical (lowercase) GUID keys are admitted. Chronicle.Testing supports decision reads in-process. This is the client part of the design for #4138.
Chronicle (Release v19.9.0): A unit of work that holds a decision read is completed only by its owner, so application code cannot commit it early and bypass the guard. The ASP.NET Core unit-of-work middleware owns its request’s unit of work.
Chronicle (Release v19.9.0): GetDecisionConflicts explains a rejected guarded append without exposing sequence numbers.
Arc.TypeScript (v0.38.0): DrizzleReadModels.observe(filter?) and observeById(key) return a live RxJS observable with current(), which model-bound observable queries can return and serve over SSE and WebSocket like any observable query.
Arc.TypeScript (v0.38.0): observePage(filter, options) emits QueryPage results for low-level defineObservableQuery definitions; generated proxies don’t support observable pages yet.
Arc.TypeScript (v0.38.0): DrizzleHandle.notifyChanged(tableOrReadModelType) announces a write. Inside an Arc command, notifications from the command and its nested commands are published once, when the outermost command finishes (also when it fails). Outside a command they are published immediately.
Arc.TypeScript (v0.38.0): The proxy generator recognizes query results whose class derives from an RxJS Observable or Subject, such as the observables returned by MongoDB and Drizzle read models, and asks for an Observable<...> annotation when it can’t resolve the item type.
Arc.TypeScript (v0.37.0): ChronicleQueryScenario.for(Model, 'method', ...artifacts) runs a model-bound query against Chronicle read models without a kernel. Seed state per event source with given.forEventSource(id, tenant?): .events(...) builds reducer-backed read models with the Chronicle SDK’s ReadModelScenario, and .readModel(instance) pins an instance, which wins over seeded events. Reads are tenant-scoped, and an unseeded key resolves as missing.
Arc.TypeScript (v0.37.0): Listing, watching and projection-backed history need ChronicleKernelScenario, and the scenario says so rather than returning a partial answer.
Arc.TypeScript (v0.37.0): snapshotStreamSource(result) in @cratis/arc.core returns the stream a snapshot query returned by mistake, so a test host can release it.
Arc.TypeScript (v0.36.0): ARCCHR0006 in @cratis/eslint-plugin-arc-core’s recommended-type-checked preset. It reports a Chronicle @reactor() event handler that returns an Arc @command() without a replay decision: @onceOnly() on the reactor or handler, or a @replay() handler for the same event. Replaying the reactor would otherwise execute the command again.
Arc.TypeScript (v0.36.0): It follows async handlers, returned arrays and tuples, and helpers in the same class whose result the handler returns, including class-expression reactors.
Arc.TypeScript (v0.36.0): It does not follow inherited or external helpers, handlers whose event parameter isn’t typed as the event class, decorated classes that only come from .d.ts files, or commands executed manually through an Arc server. The ARCCHR0006 page lists these limits.
Arc (Release v22.26.0): Select a tenant with ITenantScope.Begin for commands, validation, queries, and tenant-scoped reads in background work. The selection takes precedence over request tenant resolution inside the current flow. Dispose to restore the previous tenant; disposal is idempotent, and disposing an outer scope early leaves an active inner tenant selected until it ends (#2747)
Arc (Release v22.26.0): Custom ITenantIdAccessor registrations are preserved whether they are registered before or after Arc. Explicit tenant scopes require Arc’s TenantIdAccessor as the effective accessor; resolving ITenantScope with a custom accessor throws ExplicitTenantScopeRequiresArcAccessor instead of silently selecting a tenant that downstream services cannot see.
Arc (Release v22.26.0): Independent HTTP requests reset inherited tenant selection when they enter Arc’s request pipeline, before authentication and tenant-bound resolution. On ASP.NET Core this covers all application middleware, but not middleware added by another IStartupFilter registered before Arc’s. Observable emissions use the subscriber’s tenant, not a producer’s explicit tenant, on every streaming transport. Tasks and timers started inside a tenant scope keep its tenant after the scope is disposed: do not carry that captured context into unrelated work.
Arc (Release v22.26.0): Configurable access to the command and query introspection catalogs (/.cratis/commands and /.cratis/queries) through Cratis:Arc:Introspection (ArcOptions.Introspection) (#2764):
Arc (Release v22.26.0): Enabled (default true): set to false to leave both routes unmapped.
Arc (Release v22.26.0): RequireAuthentication (default false): deny anonymous callers. Arc.Core returns 401; ASP.NET Core uses the configured scheme’s challenge behavior.
Arc (Release v22.26.0): Roles (comma-separated, any one grants access, requires RequireAuthentication): deny callers without a listed role. Arc.Core returns 403; ASP.NET Core uses the configured scheme’s forbid behavior.
Arc (Release v22.26.0): TrustForwardedIdentityHeaders (default false): lets the Microsoft Identity Platform header handler authenticate protected catalog requests; enable it only behind a trusted ingress that replaces those headers.
Arc.TypeScript (v0.35.0): /openapi.json describes POST <command route>/validate for every command, with the execute operation’s request body, tag, and security requirements. Its responses are the untyped command result envelope, and its operationId is <command operationId>:validate.
Arc.TypeScript (v0.35.0): GeneratedReturn is exported as a type, so low-level defineQuery and defineObservableQuery descriptors can declare their return cardinality.
Arc (Release v22.25.0): A model-bound command can declare [BlockOnValidationSeverity(ValidationResultSeverity.Warning)], or Information, so that warning- or information-level validation failures reject it. The declared severity is the lowest severity that blocks. It applies to HTTP execution, validation, Provide() and in-process ICommandPipeline execution, and derived command records inherit it. (#2760)
Arc (Release v22.25.0): Generated TypeScript proxies carry the declared severity and apply the same threshold on the client. The server stays authoritative. An out-of-range declared severity fails proxy generation.
Arc.TypeScript (v0.34.0): ValidationResult.information(message, options?), ValidationResult.warning(message, options?), and ValidationResult.error(message, options?) construct validation results at a chosen severity.
Arc.TypeScript (v0.34.0): The options object sets members, state, reason, and reasonDetail. reason defaults to rule, and omitted options are left out of the result.
Arc.TypeScript (v0.34.0): state and reasonDetail reach the command and query HTTP result envelopes. state must be JSON-serializable.
Arc.TypeScript (v0.34.0): ValidationResultOptions is exported for typing those options.
Stage (Release v4.19.0): Stage accepts Screenplay’s typed-context descriptors (Screenplay 4.41) alongside a model’s implementation attachments. LoadedSemanticModel.TypedContextDescriptors, the matching ArtifactRenderRequest members and a new CratisRendering.Plan overload carry them from the same compilation. Stage admits descriptor contract revision 1 only, and refuses descriptors that are not ready for wrapper generation, come from another compilation, are malformed or incomplete, with STAGE-ESM-021.
Stage (Release v4.19.0): Stage generates typed C# contexts from the descriptors for validation, never falling back to dynamic. No generated code uses them yet: they are emitted once reducer bodies render. This is part of #151.
Arc.TypeScript (v0.33.0): scenario.given.forEventSource(sourceId, tenant?).events(...events) seeds ordered history for an event source.
Arc.TypeScript (v0.33.0): When a command reads a reducer-backed read model for that source (through commandReadModel, readModelForValidation or provide()), the scenario builds it from the seeded events. It uses the Chronicle SDK’s in-process ReadModelScenario, so the kernel isn’t needed.
Arc.TypeScript (v0.33.0): Seeded events never count as events the command appended.
Arc.TypeScript (v0.33.0): Seeding history needs @cratis/chronicle 6.14 or later. It is loaded only when history is seeded, so the package’s peer range stays ^6.7.0.
Arc.TypeScript (v0.33.0): scenario.given.forEventSource(sourceId, tenant?).readModel(instance) pins a read model for a source. A pinned instance wins over seeded history.
Arc (Release v22.24.0): QueryScenario<TReadModel> runs model-bound snapshot queries in-process through the same hosted pipeline as the HTTP endpoint, including argument conversion, authorization, validation, interceptors and owned query scopes. The principal comes from an ICurrentPrincipalAccessor registered in Services, as with CommandScenario. (#2762)
Arc (Release v22.24.0): IQueryScenarioExtender is a seam for extending query scenarios. Cratis.Arc.Chronicle.Testing uses it to seed read models and event history for Chronicle-backed queries, including other read model types the query reads.
Arc (Release v22.24.0): Query scenarios materialize lazy results that depend on scoped services before releasing the query scope, so the result stays readable after Perform returns.
Arc.TypeScript (Arc for TypeScript 0.32.0 — Chronicle lint rules): ARCCHR0003: a reactor appends to an event store field it got from its own client or runtime, instead of returning the event. The rule cannot prove the store is the reactor’s own, and the documentation says so.
Arc.TypeScript (Arc for TypeScript 0.32.0 — Chronicle lint rules): ARCCHR0007: a command’s handle() or provide() appends to the event log directly. That includes stores reached through injected ChronicleReadModels or ChronicleRuntime, and .transactional appends. Such appends escape the command’s batch; return the events instead.
Arc.TypeScript (Arc for TypeScript 0.32.0 — Chronicle lint rules): ARCCHR0009: a command property with a secret-looking name that Arc does not mask at runtime, such as passphrase, privateKey, accessKey, pin, otp, cvv, securityCode or authorizationHeader. It is reported only when @cratis/arc.chronicle is installed, skips number, boolean, date and GUID fields, and is silenced by @notAudited() or @pii().
Arc.TypeScript (Arc for TypeScript 0.32.0 — Chronicle lint rules): ARCCHR0010: a keyless command returns a Guid beside an event instead of an event source ID response. This rule needs type information.
Arc.TypeScript (Arc for TypeScript 0.32.0 — Chronicle lint rules): The Chronicle code analysis page maps every .NET ARCCHR diagnostic to a TypeScript rule, a runtime check, or the reason it does not apply.
Components (Release v4.15.0): DataTableForQuery, DataTableForObservableQuery, and DataPage show a loading row while the first result is on its way, and a failure row when the query fails or the user is not authorized. A table that is refreshing rows it already shows keeps them visible and marks itself busy (aria-busy on the table, data-busy on the root). Server exception text is never shown. (#327)
Components (Release v4.15.0): loadingMessage, failureMessage, and unauthorizedMessage props on DataTableCore, both query tables, and DataPage, with provider-wide defaults in CratisComponentsProvidermessages.dataTable.loading, .failed, and .unauthorized. (#327)
Components (Release v4.15.0): DataTableCore accepts status (DataTableStatus.Ready, Loading, Failed, or Unauthorized) so a table over local rows can show the same states. (#327)
Components (Release v4.15.0): New stable parts loading-row, loading-cell, failure-row, and failure-cell (typed as loadingRow, loadingCell, failureRow, and failureCell in DataTableParts). The failure cell carries data-reason, and the loading and failure text are announced to screen readers through role="status" and role="alert". (#327)
Components (Release v4.15.0): PivotViewer announces its loading state to screen readers, labeled by the new loadingLabel prop (default Loading…). (#328)
Chronicle (Release v19.8.0): Testing scenarios accept per-run artifacts. Pass new Defaults(clientArtifactsProvider, serviceProvider) to EventScenario or ReadModelScenario, so each test run discovers only the artifacts you give it, not the assembly-wide set.
Chronicle (Release v19.8.0): EventScenario(Defaults, ICanProvideConstraints?) discovers constraints from the supplied defaults when no constraint provider is passed.
Chronicle (Release v19.8.0): ReadModelScenario<TReadModel>.WithProjection(Action<IProjectionBuilderFor<TReadModel>>) defines a projection inline for a single scenario. It takes precedence over discovered projections and reducers, and it does not leak into other runs.
Arc.TypeScript (Arc for TypeScript 0.31.0 — global command and query filters): AuthorizationCommandFilter and CommandPipelineFilter apply to every command. AuthorizationQueryFilter and QueryPipelineFilter apply to every query snapshot and observable subscription. Register them through ArcOptions, the builder’s add… methods, or the matching decorators.
Arc.TypeScript (Arc for TypeScript 0.31.0 — global command and query filters): Command and query contexts carry operationName, the declared name of the operation, the same as CommandContext.Type and QueryContext.Name in .NET. Framework-built contexts always set it, and it cannot be changed. Filters that rely on it must deny or handle a manually built context without it.
Components (Release v4.14.2): ColumnsProps is exported from @cratis/components/DataPage for the props of DataPage.Columns. ColumnProps from that subpath is unchanged and still describes a table column. (#333)
Screenplay (Release v4.41.0): Screenplay publishes typed-context descriptors: language-neutral data describing exactly what each code body can see, so providers such as Stage can generate typed wrappers instead of dynamic contexts. They cover reducer transitions (a typed Event per on event using its current generation, and a nullable State shaped like the read model), validation and rule code, code policies at each place they are used, and the context of command handlers, which are still not bound. This is the descriptor part of decision 0012 and advances #139.
Screenplay (Release v4.41.0): CompilationResult exposes the descriptors through TypedContextDescriptors and ContextsFor(requirementId). IsWrapperReady is true only for descriptors from a successful compilation whose types all resolve; a failed compilation publishes only command-handler descriptors, marked not ready. Every descriptor carries the definitions of the concept and composite types it refers to.
Screenplay (Release v4.41.0): MCP has a paged typed-contexts view; implementation-requirements items gain a small typedContext reference (count and operation ids).
Screenplay (Release v4.41.0): The descriptor contract has its own revision (1), a published vocabulary of portable type tokens and source kinds, and two readable vectors (typed-contexts-v1.json, unbound-handler-context-v1.json) packaged with the canonical vectors. Canonical executable-model bytes and revisions are unchanged.
Chronicle.TypeScript (Release v6.14.0): @cratis/chronicle/testing exports ReadModelScenario. Seed history with scenario.given.forEventSource(id).events(...), then read await scenario.instance or await scenario.instanceForEventSourceId(id). wasDeletedForEventSourceId(id) tells a deleted read model apart from one that never materialized.
Chronicle.TypeScript (Release v6.14.0): Events go through the same reducer dispatch and the same event serialization as production. Concept values are therefore flattened exactly as they are when appended.
Chronicle.TypeScript (Release v6.14.0): The event context carries the same defaults as the kernel, sequence numbers are global in seed order, and each event source is reduced separately.
Chronicle.TypeScript (Release v6.14.0): A reducer that fails is reported with the read model and reducer names and the original error as its cause.
Chronicle.TypeScript (Release v6.14.0): A read model built by a projection is rejected with a clear message; test it against a kernel instead.
Chronicle (Release v19.7.3): CHR0054 reports a reactor method whose return type Chronicle cannot discover as a handler, with a message about the return type (#4206)
Chronicle.Elixir (Release v3.6.0): Chronicle.Observers - lists what the event store knows about its observers and removes one by id. For the observer whose declaring code is gone: a deleted read model and its projection, or a removed reactor. Removal covers the whole event store, since an observer’s definition (and its projection definition, where it has one) is a store-level record. The kernel refuses while the observer is running or still has a subscribed client in any namespace, naming the namespace that blocked it - there is no override. Read model data and sink containers are left untouched.
Chronicle.TypeScript (Release v6.13.0): eventStore.observers - lists what the event store knows about its observers and removes one by id. For the observer whose declaring code is gone: a deleted read model and its projection, or a removed reactor. Removal covers the whole event store, since an observer’s definition (and its projection definition, where it has one) is a store-level record. The kernel refuses while the observer is running or still has a subscribed client in any namespace, naming the namespace that blocked it - there is no override. Read model data and sink containers are left untouched.
Chronicle.Kotlin (Release v6.6.0): store.observers - lists what the event store knows about its observers and removes one by id. For the observer whose declaring code is gone: a deleted read model and its projection, or a removed reactor. Removal covers the whole event store, since an observer’s definition (and its projection definition, where it has one) is a store-level record. The kernel refuses while the observer is running or still has a subscribed client in any namespace, naming the namespace that blocked it - there is no override. Read model data and sink containers are left untouched.
Screenplay (Release v4.40.0): SemanticEvaluator.EstablishWorld(plan, facts) establishes a deterministic reference world from ordered existing facts, with no read-model snapshots required. It checks every fact first: a default or null fact array, an unknown event, a payload that doesn’t match the event, a missing or blank event-source identity, a source type other than the event’s declared producer destination type, or a blank tag returns SemanticRejected with category Contract. A fact that affects a reducer-backed read model returns SemanticUnsupported with capability Projection, because reducer transitions are opaque. This is reference semantics and does not replace Chronicle replay. (#253)
Screenplay (Release v4.38.0): A StateView slice’s specification can use when append … for, as long as exactly one command produces the event and so determines the source type. (#262)
Chronicle.TypeScript (Release v6.12.0): @index() marks a read-model property to be indexed, including properties in nested objects and in typed child collections. Paths are joined with dots, as in .NET, for example address.zipCode and lines.productId.
Chronicle.TypeScript (Release v6.12.0): Indexes are registered with the kernel at application startup for declarative projections, model-bound projections, variants and reducers, and through readModels.register(). The MongoDB sink creates the indexes.
Screenplay (Release v4.37.0): Event generations now bind to the executable model. Events with several generations share one contract identity and carry their complete prior revisions, predecessor links and revision-specific property identities. Ordinary references use the current generation. This implements decisions 0011 and 0015 and advances #71.
Screenplay (Release v4.37.0): Persisted event contracts can advance through an explicit, catalog-revision-checked workspace transaction. Renaming or moving an event preserves its identities across generations; combining a rename with evolution still requires explicit advancement.
Screenplay (Release v4.37.0): The RegisterProject v2 canonical corpus declares two event generations, removes the duplicated projectId from the current event payload and uses the event source as its identity. Single-file, folder, reordered and relocated forms produce the same model. This advances #168.
Chronicle.TypeScript (Release v6.11.0): waitForCompletion({ timeoutMs, signal }) accepts an AbortSignal. Canceling the signal rejects the wait promptly with the signal’s reason and cancels the underlying call, including while the client is still waiting for an access token. Other calls that wait for the same token are not affected. The existing waitForCompletion(timeoutMs) form and its five-second default are unchanged.
Chronicle.TypeScript (Release v6.10.0): RejectedChronicleCredentials: the client now stops retrying and rejects getEventStore(...) and later calls when the credentials are rejected. This applies when the token endpoint answers invalid_client, unauthorized_client, or invalid_grant, or the kernel refuses an API key, on three consecutive attempts. Previously a wrong password made getEventStore(...) wait forever.
Chronicle.TypeScript (Release v6.10.0): @childrenFrom(Event, ChildType, identifiedBy?, parentKey?) accepts the child class as its second argument. Use it under runtimes that emit no type metadata, such as tsx, so the client knows the element type of a children collection.
Chronicle.TypeScript (Release v6.10.0): A root yarn test script.
Screenplay (Release v4.36.0): MCP can export the compiled executable model: read-workspace view executable-model returns its schema, language and semantic versions, model revision and size, plus bounded base64 pages of the exact canonical bytes. It is available only when compilation succeeded; otherwise it reports available: false and points to the executable-diagnostics view. Continuation pages must pass expectedModelRevision and expectedAttachmentManifestRevision, and are refused if the model or any attached code changed, including a code edit that changes neither the workspace nor the model revision. The exported model alone is not a proof of equivalence or a runnable attachment bundle (decision 0016).
Screenplay (Release v4.36.0): implementation-requirements responses include the attachment-manifest revision. Passing it back pins a continuation and refuses it if attached code changed; continuations without it work as before.
Chronicle.Kotlin (Release v6.5.0): set(...).toValue(value) on the fluent projection builder sets a constant. toValue(null) clears the property.
Chronicle.Kotlin (Release v6.5.0): Passive reducers (@Reducer(isActive = false), or a reducer whose read model is @Passive) are folded in the client from the reducer’s event sequence on getInstanceByKey and getInstances, so they return current state.
Chronicle.Kotlin (Release v6.5.0): ChronicleConnectionFailed is thrown by awaitRegistration() and by appends that wait for registration when the kernel rejects the connection: wrong credentials, missing permission, or an incompatible server. The client keeps retrying and recovers when the kernel accepts a connection.
Chronicle.Kotlin (Release v6.5.0): ChronicleServerIncompatible (an IllegalStateException) is thrown when the compatibility check fails.
Chronicle.Kotlin (Release v6.5.0): ArtifactRegistrationFailed is thrown from an explicit registerAll() that could not start one or more reactors or reducers, naming each one.
AI (Release v7.0.0): A decision engine choice: the built-in Decision Engine or TypeSafe’s Jev, selected with UseBuiltInDecisionEngine or UseJevDecisionEngine. Exactly one engine is in force at a time; until one is chosen, decisions go to the built-in engine
AI (Release v7.0.0): Jev support: an API key (encrypted at rest and kept out of the causation chain), a model defaulting to jev-latest and an endpoint defaulting to https://api.typesafe.ai. Questions that share a context are sent as one request
AI (Release v7.0.0): The built-in engine’s address and model are deployment configuration under Cratis:AI:Decisions:BuiltIn, bound through IOptions<BuiltInDecisionEngineOptions>
AI (Release v7.0.0): DecisionEngineSettings.CurrentDecisionEngine returns the engine in force, its model and a cached health check for a settings page. The API key is never returned
AI (Release v7.0.0): Decision usage: RecordDecisionUsage and the DecisionUsageByDay read model, with DecisionUsageForLastThirtyDays
AI (Release v7.0.0): A DecisionRequest can carry the question being asked, a description of each choice and a topic. The Decision Engine includes the question and descriptions in its prompt; without them it keeps the generic question
AI (Release v7.0.0): CratisAIBuilder.WithDecisions() registers decision making, and WithDecisions<TResolver>() replaces how the engine is resolved
Chronicle.TypeScript (Release v6.9.0): Class-level @onceOnly() registers a reactor as not replayable, so the kernel never replays it. The marker is not inherited, as in .NET.
Chronicle.TypeScript (Release v6.9.0): Method-level @onceOnly() skips that handler when an event is delivered during a replay.
Chronicle.TypeScript (Release v6.9.0): @replay() marks a handler that runs instead of the regular handler for its event type during a replay.
Chronicle.TypeScript (Release v6.9.0): The shared Chronicle documentation shows TypeScript examples for once-only and replay handlers.
AI (Release v6.5.0): Kubernetes workers can keep their workspace on a volume of their own. Set Cratis:AI:ContainerRuntime:ScratchStorageClassName and ScratchSize, and each worker gets a volume provisioned from that class, mounted at /workspace and removed with the worker. A checkout and its build output then no longer fill the node’s disk or compete with other workers on it. Use a storage class that deletes volumes with their claim and binds on first consumer. Leaving either setting unset keeps today’s behavior.
Chronicle (Release v19.7.0): The event-store dashboard, built from projections with composite keys rather than counting rows on demand, with per-namespace figures and drill-down, and key figures under each event store on the landing page (#3731)
Chronicle (Release v19.7.0): A declarative surface for kernel-owned projections - identified with a $system. prefix, owned by the kernel rather than a client, and refused by replay, because replaying one rebuilds state the kernel keeps for itself
Chronicle (Release v19.7.0): ProjectionScope, so a read model can be built per namespace, once for the whole store, or both. A Both declaration lowers to two single-scope definitions, and a global one is keyed with the unset namespace
Chronicle (Release v19.7.0): A statistics query surface over the new projections, and the Workbench screens that show it
Chronicle.TypeScript (Release v6.8.0): @unique() marks an event property or an event class as unique. @removeConstraint(name) releases a named constraint, can be repeated, and is inherited like the .NET attribute.
Chronicle.TypeScript (Release v6.8.0): The shared constraint pages on the Chronicle documentation site now show TypeScript examples for model-bound constraints.
AI (Release v6.4.0): cratis-content-length: when content stays short, when it earns more length, and where to split it. It has pilot bands for LinkedIn, documents, video, X, Bluesky, Mastodon, community answers, blog articles, tutorials, newsletters, YouTube and release notes, and says which platform limit or soft trigger applies. Each band states how strong its evidence is. It also sets batch-variety targets so a feed doesn’t read as one length.
AI (Release v6.4.0): cratis-developer-marketing: plans how developer content earns real engagement and adoption. It covers positioning around what developers evaluate (docs, trials, peers, APIs, limits), hooks without bait, the move from pillar to canonical source to channel-native entry points, community participation, founder and company voice, a sustainable cadence, and a staged measurement framework with a small-sample experiment design.
AI (Release v6.4.0): The voice and cadence skill gains a catalog of 21 AI-sounding patterns (lexical, syntactic, structural and tonal), each with a script heuristic and the human alternative. It checks a batch for sameness, fixes problems with substance, and includes a meaning-preservation check that handles curly apostrophes. It is explicitly an editing aid, never an authorship detector.
AI (Release v6.4.0): The feed post skill leads with media that explains, and puts the Cratis mark on every image, document page, GIF frame and video; screenshots are framed, never stamped. It has guidance for adapting a post to other channels, and a dated evidence matrix with a URL for every source.
AI (Release v6.4.0): Both new skills are in the cratis/content profile.
Screenplay (Release v4.35.0): MCP can propose a fix for a diagnostic: read-workspace has a repairs view listing the compiler-authored repairs for the workspace’s diagnostics (code, subject and typed operations), and propose-repair turns one into a retained proposal. Review it with read-proposal and write it with apply; nothing is written before that, and a stale workspace revision is refused with a typed conflict.
Screenplay (Release v4.35.0): The first repair migrates a deprecated validate csharp block (PLAY0397) to a tagged ```csharp fence. The code body, its requirement identity and content hash, and the executable model are unchanged. The repair reprints the whole file canonically, so it is refused if that would drop a comment. Other PLAY0397 forms are not offered a repair.
Screenplay (Release v4.35.0): Library hosts can find and propose repairs through WorkspaceDiagnosticRepairs.Find and ProposeRepair, which require canonical formatting (RequiredFormatting).
Screenplay (Release v4.35.0): Adding a node whose references don’t resolve is refused under the safe reference policy, which is how decision 0014 covers “link” in #138.
Screenplay (Release v4.34.0): Events can declare their generations: event ProjectRegistered generation 2. An event without the marker is generation 1 and prints as before. Each earlier generation is a complete declaration in the same slice, numbered consecutively from 1; an invalid, duplicate or missing generation is a compile error (PLAY0446, PLAY0447, PLAY0448). Printing, workspace and MCP authoring, and editor highlighting, completion and hover support the marker. This is the grammar part of decision 0011 for #71.
Screenplay (Release v4.34.0): A model that uses the marker does not compile to the executable model yet: binding fails with PLAY0449 until generation lineage ships (decision 0015). Models without the marker are unchanged.
cli (Release v3.19.0): chronicle observers remove — removes an observer whose declaring code is gone (a deleted read model and projection, or a removed reactor), clearing its definition, state, handled counts and failed partitions across every namespace of the event store. Asks for confirmation first, stating what is deleted, that it reaches every namespace, that read models and their data are left alone, and that it cannot be undone. The kernel refuses while the observer is running or a client is still subscribed to it, and the command reports that refusal rather than reporting success.
cli (Release v3.18.0): cratis render reads the implementation files a model references (file ... on policies, validation, reducers and other code) from the model folder, or from a single .play file’s folder, and gives their contents to the Screenplay compiler, so file-backed code is identified by content. (#184)
cli (Release v3.18.0): A file the loader refuses (outside the model folder, a link, missing, too large or not text) is reported as PLAY0430–PLAY0434, even when compilation fails. (#184)
Chronicle (Release v19.6.0): [NotProjected] declares a read model member that the projection deliberately does not populate, because whatever reads the model assembles it. A projection may only consume events, never another read model, so a value joined in from a second read model can only be filled in by the query that serves it — and there was previously no way to say so. Declaring it also fences AutoMap off the member, so a subscribed event carrying the same name can no longer write over the assembled value
Arc.TypeScript (Arc for TypeScript 0.28.0 — Chronicle personal data in directly read models): Chronicle read models that contain @pii() or @encrypted() data are decrypted before a query serves them, when the query reads them directly from their MongoDB collection through MongoCollection. This covers nested properties, array items, class-level markings, single results, arrays, pages and observable emissions.
Screenplay (Release v4.33.0): Screenplay can show which read-model instances each projection event affects, derived from the executable model with no new syntax: one instance by key (from, removal), one per event source (all), or many through a root join (instances whose join property equals the event source id, never creating one) or a child join and remove via join (children whose identity equals the key, across every parent). SemanticAffectedProjectionInstances.GetAffectedInstances returns the relationships per event and block, with an overload that uses the application’s types to resolve a child identity. This is the first part of decision 0007 for #132.
Chronicle (Release v19.5.0): Removing an observer and everything the event store keeps for it — its definition, its state and handled counts in every namespace, its failed partitions, its in-flight events and, for a projection, its projection definition. Refuses while the observer is running or still has a subscribed client in any namespace, naming the namespace that blocked it. Read model data is left untouched (#4151)
Chronicle (Release v19.5.0): EventStore.Observers on the .NET client, for listing the observers of an event store and removing one (#4151)
Chronicle (Release v19.5.0): A Remove action on the Workbench observers page, with a confirmation that states what removal deletes, what it leaves alone and that it cannot be undone (#4151)
Stage (Release v4.17.0): Render inputs can carry a Screenplay model’s implementation attachments: the compiler’s requirements and each resolved body, keyed by requirement id. Inline bodies come from the source; file bodies are loaded through Screenplay’s AttachmentFiles from the model root. LoadedSemanticModel exposes the requirements, the bodies and the loader’s attachment diagnostics, and new CratisRendering.Plan overloads accept them.
Stage (Release v4.17.0): Planning verifies every supplied body against its requirement’s content hash. A body the model references that is missing, refused by the loader, or changed since compilation fails with STAGE-ESM-020, which names the requirement and the loader’s reason (PLAY0430–PLAY0434), and no artifacts are produced.
Orleans (Release v1.10.0): Jobs can run their steps in ordered stages. Give a step a stage with CreateStep<TJobStep>(request, stage) (or JobStepDetails.Stage): every step in a stage reaches an outcome before any step in a later stage starts, and the steps within a stage still run in parallel. A job that never assigns a stage has every step in JobStepStage.First and runs exactly as before. (#27)
Orleans (Release v1.10.0): A stage with a failed step stops the job by default. Every step behind it is recorded with the new JobStepStatus.Unreachable status and counted in JobProgress.UnreachableSteps, and the job ends CompletedWithFailures because it can account for every step. Override GetFailureBehaviorFor to return JobStageFailureBehavior.ContinueWithNextStage for a best-effort stage. (#27)
Orleans (Release v1.10.0): JobProgress.Stages reports the progress of each stage. It stays empty for a job with a single stage. (#27)
Orleans (Release v1.10.0): A resumed job continues from the stage it had reached. This includes a job that a stopped silo left between two stages, whether that was after one stage completed or at a failed barrier that nothing had acted on yet. (#27)
Orleans (Release v1.10.0): Job.KeepAfterCompletedWithFailures lets a job remove its persisted state after completing with failures. The default is true, which keeps today’s behavior. A job that runs on a short cadence can override it so it does not keep a record of every failed run.
Arc.TypeScript (Arc for TypeScript 0.27.0 — Drizzle read models in commands): A command that declares @inject(commandReadModel(Model)) receives the Drizzle row whose primary key equals the command key. The row is read from the current tenant’s database.
Arc.TypeScript (Arc for TypeScript 0.27.0 — Drizzle read models in commands): DrizzleReadModels.findById(key) loads a row by the table’s single primary key. Arc’s own custom columns get a typed key, and plain columns get a primitive. Invalid number and GUID keys are rejected with a clear error.
Screenplay (Release v4.32.0): read-workspace has a paged source-map view: the compiler’s map from each semantic id to its role, identity origin, document and exact source span. When compilation did not succeed it reports available: false and points to the executable-diagnostics view instead of returning an empty map.
Screenplay (Release v4.32.0): find-fixtures finds the payload values and for destinations of when append events, with the role whenAppendedEvent.
Screenplay (Release v4.32.0): Compact specification summaries show a then denied assertion and the appended event of a when append specification.
Screenplay (Release v4.31.0): Reaction triggers can declare the views they decide from: reads <View> [as <alias>] [by <trigger value>], with the same alias rules as command reads. Parsing, validation, printing, the syntax walker, MCP references, and editor highlighting, completion and hover all support it.
Screenplay (Release v4.31.0): Diagnostics for trigger reads: an unknown view, a repeated view without an alias, a duplicate alias, an alias that collides with a trigger value, a by that names no trigger value (PLAY0442, warning), a by under a clock trigger (PLAY0443, error), and a primitive type read as a view (PLAY0444, warning, pointing to @reads).
Arc.TypeScript (Arc for TypeScript 0.25.0 — kernel-backed Chronicle tests and read consistency): ChronicleKernelScenario in @cratis/arc.chronicle/testing runs commands against a real Chronicle kernel: seed events, execute commands through Arc’s pipeline, wait for projections through the kernel’s own completion signal, and assert on appended events, read models and constraint violations. The in-memory ChronicleCommandScenario stays the fast default.
Arc.TypeScript (Arc for TypeScript 0.23.0 — Chronicle read model queries): ChronicleReadModels reads read models for the current tenant with getAll(Type) and getById(Type, id), and observes them as RxJS observables with observeAll(Type) and observeById(Type, id), so observable queries over Chronicle read models need no custom plumbing.
Stage (Release v4.16.0): The opt-in semantic Stage engine (Stage__Runtime__Engine=semantic) can start on a Chronicle event log that already holds events. It rebuilds its semantic world only when that can be done exactly: every projection is mirrored exactly and has caught up with its own events without failed partitions, every logged event converts back exactly, and the history satisfies the model’s constraints. Otherwise it refuses with a specific Unsupported(World) status. (part of #23)
Stage (Release v4.15.0): A render profile can carry the model’s .strings catalog. Generated validators then resolve $strings.<key> rule and requirement messages for the request’s UI culture, falling back through its parent cultures to the default locale. The key stays in the validation result’s state, and generated rejection specifications compare that key, as the Screenplay reference does. A key missing from the default locale fails planning with STAGE-ESM-018. Without a catalog, $strings messages are still rejected. (part of #116)
Arc.TypeScript (Arc for TypeScript 0.21.0 — vertical slices and the Library sample): The Library sample: an event-sourced Arc and Chronicle application with a React frontend using generated proxies. Commands return events, a Chronicle constraint keeps author names unique, projections build the read models, and observable queries update the frontend live. A Docker Compose file starts the Chronicle kernel.
Arc.TypeScript (Arc for TypeScript 0.21.0 — vertical slices and the Library sample): A vertical slices guide: one file per slice holds the command, its validator and its events, or the read model with its queries and projection, as in Cratis C# applications. Discovery, proxy generation, generated artifact metadata and the ESLint rules all support several artifacts in one file.
Arc.TypeScript (Arc for TypeScript 0.20.0 — Fetch runtimes): @cratis/arc.core/fetch, an entry for runtimes that speak the Fetch API: build an application from explicitly added artifacts (or generated artifact metadata) and serve commands, queries and observable queries over server-sent events with app.fetch(request). Its only platform import is node:async_hooks, which Deno, Bun, Cloudflare Workers (with Node.js compatibility) and Next.js provide.
Arc.TypeScript (Arc for TypeScript 0.20.0 — Fetch runtimes): Verified on Deno 2.9: a command, a query and an observable query over SSE. Bun, Cloudflare Workers and Next.js route handlers have examples but are not yet verified.
Arc.TypeScript (Arc for TypeScript 0.19.0 — setup, configuration and host integrations): builder.withChronicle(...), builder.withMongoDB(...) and builder.withDrizzle(...), named like .NET’s WithChronicle and WithMongoDB. Importing an integration package adds its method to the builder through a typed extension that also works when two copies of @cratis/arc.core are installed.
Arc.TypeScript (Arc for TypeScript 0.19.0 — setup, configuration and host integrations): Configuration like .NET’s: ArcApplication.createBuilder() reads the Cratis:Arc, Cratis:Chronicle and Cratis:MongoDB sections from appsettings.json and appsettings.{Environment}.json, and from Cratis__... environment variables. Values are converted per setting, .NET key names such as CorrelationId:HttpHeader and GeneratedApis:EnableQueryHttpMethod are accepted, other sections are ignored, and options set in code win. Use configuration: false to opt out or configuration: { file, env } to choose the source.
Arc.TypeScript (Arc for TypeScript 0.19.0 — setup, configuration and host integrations): @cratis/cratis, the counterpart of the C# Cratis package: CratisApplication.createBuilder() or builder.addCratis() sets up Arc with Chronicle in one call. Unlike C#, it installs no authentication handler; choose one explicitly.
Arc.TypeScript (Arc for TypeScript 0.18.0 — RxJS observable queries): Observable queries can return RxJS subjects and observables, just as a C# query returns ISubject<T>. A BehaviorSubject answers plain HTTP requests with its current value (200), while a Subject, ReplaySubject or Observable without a current value answers 202 or waits, as in .NET. Completion, errors and client disconnects end the subscription. Async iterables keep working.
Arc.TypeScript (Arc for TypeScript 0.18.0 — RxJS observable queries): The proxy generator and generated artifact metadata recognize RxJS Observable, Subject, BehaviorSubject and ReplaySubject return types as observable queries.
Arc.TypeScript (Arc for TypeScript 0.18.0 — RxJS observable queries): arc-proxygenerator --watch reports Watch ready once the first generation has finished and the watcher is armed, and notices edits to referenced files outside the artifacts folder.
Arc.TypeScript (Arc for TypeScript 0.17.0 — OpenAPI results and proxy improvements): /openapi.json describes results: command and query result envelopes with the typed response or data (from generated artifact metadata), paging on paged queries, and the 200, 400, 403 and 500 responses, plus 202, 408 and 503 for observable queries.
Stage (Release v4.14.0): A conformance suite runs every canonical-corpus specification through Screenplay’s reference runner, Stage’s semantic engine, and the specifications of the rendered application, and checks that all three agree wherever each can execute it. (part of #15)
Chronicle.TypeScript (Release v6.7.0): Read models are recognized from the projections, reducers and model-bound projection decorators that build them, the way the .NET client discovers them, so a read-model class needs no extra decorator. Use static readModelId on the class to choose a custom identifier.
Chronicle.TypeScript (Release v6.7.0): Event types can be constructed naturally, for example new TaskCreated(title): an event class with a constructor and @field properties serializes, generates its schema and deserializes correctly in both standard and legacy decorator modes.
Arc.TypeScript (Arc for TypeScript 0.16.0 — Chronicle aggregates and reactor commands): AggregateRoot and @inject(commandAggregate(Author)): a command receives the aggregate for its key, rehydrated from the event log on the command’s route. Events passed to apply() join the command’s batch and are appended when the command succeeds, with a concurrency scope on the event source so a concurrent change is rejected. Aggregates without handlers work too, and handlers are registered per event type with an optional event context.
Arc.TypeScript (Arc for TypeScript 0.16.0 — Chronicle aggregates and reactor commands): Reactor commands: a Chronicle reactor can return Arc commands, which run through Arc’s pipeline in the event’s namespace with causation from the event. A failed command fails the reactor partition.
Arc.TypeScript (Arc for TypeScript 0.16.0 — Chronicle aggregates and reactor commands): Transactional commands: returned events can be combined with command operations again. If Chronicle rejects the append, the operations are compensated; if the outcome is unknown, the command is reported as indeterminate.
AI (Release v6.1.0): The GitHub Copilot provider: device-flow sign-in, API-token exchange, harness support, and model listing. It was left behind when the provider backend moved into the package, so Copilot could not be configured at all through Cratis.AI - every other vendor could.
AI (Release v6.1.0): CopilotCredential.ExpiresAt, which the device-flow refresh uses to tell when a token has run out.
Chronicle.TypeScript (Release v6.6.0): reactorResultHandler in ChronicleOptions lets an application handle values a reactor returns that are not events, for example commands for a CQRS framework to execute. The handler receives the returned value, the triggering EventContext, the reactor type, the event store name and the namespace, and returns true when it handled the whole result or false to let Chronicle append the events it recognizes. A handler that throws fails the partition, so a side effect is never acknowledged without having run.
Arc.TypeScript (Arc for TypeScript 0.15.0 — generated artifact metadata): arc-proxygenerator --metadata <file> writes a metadata module from the same analysis that generates proxies: parameter bindings for handle(), provide() and @query methods (services by class, query arguments by name and type, provided values and markers such as commandContext(), abortSignal() and commandReadModel()), result shapes, field options and validator targets. It is the counterpart of Arc on .NET’s source-generated metadata.
Arc.TypeScript (Arc for TypeScript 0.15.0 — generated artifact metadata): builder.useGeneratedMetadata(metadata) applies it. Explicit decorator arguments still win, and a stale module fails at startup with a message to regenerate. --check-metadata verifies in CI that the committed module matches the source, and --watch regenerates it while you develop.
Arc.TypeScript (Arc for TypeScript 0.15.0 — generated artifact metadata): Nullable service parameters receive null when the service is not registered, as in .NET. Unions of several classes and other ambiguous parameters are reported with file and line.
Arc.TypeScript (Arc for TypeScript 0.15.0 — generated artifact metadata): The Tasks sample uses the C#-shaped commands and queries with generated metadata, and keeps one example with explicit tokens for projects without a generation step.
Stage (Release v4.13.0): The Stage sandbox can run a model on the Screenplay executable semantic model with the opt-in Stage__Runtime__Engine=semantic. The default engine is unchanged. (part of #23)
Stage (Release v4.13.0): Commands run through Screenplay’s reference evaluator. That covers authorization, validation rules and requirements, produces when, destinations, $context values and constraints, so the sandbox behaves as the model specifies.
Stage (Release v4.13.0): Accepted events are appended to Chronicle in one atomic call.
Stage (Release v4.13.0): Unauthorized commands return 403. Validation and constraint rejections return 400 with the modeled messages and constraint name. Anything the engine cannot realize exactly returns a typed 501.
Stage (Release v4.13.0): /stage/semantic/admission reports which commands, queries, events and projections the semantic engine supports, and why the others are not supported. (part of #23)
AI (Release v6.0.0): Model catalog discovery: a provider’s published models are read and recorded, so a tier can be resolved from what the vendor actually serves. Includes a background refresh, a RefreshAvailableModels command, and an AvailableAIModelDiscovery query.
AI (Release v6.0.0): ChatGPT subscription credentials - sign-in, storage, expiry-aware refresh, and the classification of whether a provider was given an API key or a subscription record.
AI (Release v6.0.0): Claude Code and OpenAI Codex as provider transports. The Anthropic client now routes to Claude Code when the credential is an OAuth token, which the Messages API will not accept.
AI (Release v6.0.0): Provider pools with failure- and capacity-aware member selection, plus PoolMemberSelector.Candidates for callers that fail over rather than picking once.
AI (Release v6.0.0): Rate-limit cooldowns, per-provider usage ceilings, configurable concurrency, and usage snapshots.
AI (Release v6.0.0): IDefaultAgentInvocationModes, which says whether a purpose runs as a job or a chat when no configured agent claims it.
AI (Release v6.0.0): Generated TypeScript proxies for all of the above, published in @cratis/ai.
Arc.TypeScript (Arc for TypeScript 0.14.0 — SQL read models with Drizzle): builder.addDrizzle({ database | databaseFactory, dialect }), or the standalone addDrizzle(builder, options) function, with a Drizzle database per tenant. A single database serves only the default tenant, and a missing tenant fails instead of reading shared data.
Arc.TypeScript (Arc for TypeScript 0.14.0 — SQL read models with Drizzle): drizzleDatabase() injects the tenant’s Drizzle database into commands and queries, and drizzleReadModel(Model) injects a read-only handle for a read model with find, findOne and queryPage.
Arc.TypeScript (Arc for TypeScript 0.14.0 — SQL read models with Drizzle): queryPage pushes Arc paging and sorting down to SQL with a count and a page-size cap. Only the read model’s declared fields that are table columns can be sorted or selected; other fields answer 400.
Arc.TypeScript (Arc for TypeScript 0.14.0 — SQL read models with Drizzle): Guides for getting started, column types and conversions, tenancy, read-only access and paging, including how the Drizzle choice compares with Kysely, Prisma and TypeORM and which Entity Framework Core features are not ported.
Arc.TypeScript (Arc for TypeScript 0.13.0 — observability, interceptors and derived types): OpenTelemetry tracing and metrics through @opentelemetry/api, using Arc on .NET’s Cratis.Arc source, span names and tag names for commands, command filters, queries and query filters, plus spans for HTTP handling, observable subscriptions and identity resolution, and duration histograms. Spans carry the correlation id. Install and configure any OpenTelemetry SDK in your application; without one, tracing is a no-op.
Arc.TypeScript (Arc for TypeScript 0.13.0 — observability, interceptors and derived types): QueryRenderer to turn a query result into what is sent (the first renderer that can render a result wins), and ReadModelInterceptor to adjust read models before they are sent, including every emission of an observable query. Both are registered on the builder or discovered, and run in the request or subscription scope.
Arc.TypeScript (Arc for TypeScript 0.13.0 — observability, interceptors and derived types): Derived types on the wire: a field declared with a base type accepts and returns classes marked with Fundamentals @derivedType('id'), using .NET’s _derivedTypeId discriminator, and JSON Schema in introspection and OpenAPI describes the alternatives.
Orleans (Release v1.6.0): Orleans.Storage.Sql.Specs. There was no specs project for the SQL provider at all, which is why a provider that could not create its own schema looked healthy. The specs run against a real SQLite database rather than substitutes - a mocked DbContext never touches a schema, so it cannot see this class of defect.
Orleans (Release v1.6.0): An end-to-end integration spec for a job with a genuinely failing step, against a real silo and a real MongoDB, asserting the failed step stays readable.
AI (Release v5.0.0): TierModelAssignment, which infers the tier ladder from a provider’s own catalog: the words vendors use at the small and large ends of their range, with the highest version winning inside a rung.
Arc.TypeScript (Arc for TypeScript 0.12.0 — Chronicle event sourcing): builder.addChronicle({ client | connectionString, eventStore, ... }), or the standalone addChronicle(builder, options) function. Each tenant uses its own Chronicle namespace, and discovered event types, projections, reducers and reactors are registered with the event store.
Arc.TypeScript (Arc for TypeScript 0.12.0 — Chronicle event sourcing): Events returned from a command’s handle() are appended after the command succeeds: a single event, an array of events, tuple(...) with a client response, or eventForEventSourceId(...) for another event source. The event source id comes from the command key (@key(), getKey() or a key resolver), and eventSourceIdResponse(id) lets a command choose it explicitly.
Arc.TypeScript (Arc for TypeScript 0.12.0 — Chronicle event sourcing): @eventSourceType, @eventStreamType, @eventStreamId, @eventSubject and tags route appended events, and eventsWithConcurrencyScopes(...) sets expected sequence numbers, including “before first”. Constraint and concurrency violations come back as validation results.
Arc.TypeScript (Arc for TypeScript 0.12.0 — Chronicle event sourcing): Events returned from nested commands in the same request are appended in one batch with the outer command’s events, only when the outer command succeeds.
Arc.TypeScript (Arc for TypeScript 0.12.0 — Chronicle event sourcing): @inject(commandReadModel(Author)) gives handle() or provide() the read model for the command’s key, from Chronicle (ChronicleReadModelForCommandResolver) or MongoDB, with { optional: true } for a model that may not exist. Ownership conflicts between resolvers fail at startup.
Arc.TypeScript (Arc for TypeScript 0.12.0 — Chronicle event sourcing): @cratis/arc.chronicle/testing with ChronicleCommandScenario, an in-memory event log and shouldHaveAppendedEvent(Event, eventSourceId?, predicate?), scoped to each execution.
Screenplay (Release v4.30.0): CodeBlockSyntax.BodyStartOffset, BodyEndOffset, BodyStart, BodyEnd and BodyLines: the body’s span in the document (UTF-16 offsets, BOM-less, as editors address text) and, for each body line, the original line and the column where its content starts after the common indentation is removed. This covers fenced bodies with a language info string and the legacy tag-line form, CRLF documents, tabs, blank and under-indented lines, and bodies at the end of a file.
Screenplay (Release v4.30.0): SemanticImplementationRequirement.BodySpan and BodyLines (SemanticImplementationBodySpan, CodeBlockSourceLine): the same map for each implementation attachment. A file attachment whose contents were supplied spans the whole file; an unresolved file attachment and an inline body without parser positions have no span.
Screenplay (Release v4.30.0): The MCP implementation-requirements views (workspace and proposal) return bodySpan and bodyLines, run-length encoded where consecutive lines share a column, so a long body stays within a page.
Arc.TypeScript (Arc for TypeScript 0.11.0 — authorization policies and identity): Named authorization policies: register a policy class (resolved from the execution scope with constructor injection) or a function with builder.addAuthorizationPolicy('Name', policy), and require it with @authorize('Name') or @authorize({ policy, roles }) on commands, read models and query methods. A policy receives the principal, the target and the resource, can be asynchronous, and an unknown policy fails at startup.
Arc.TypeScript (Arc for TypeScript 0.11.0 — authorization policies and identity): jwtBearer({ jwksUri, issuer, audience, ... }) validates bearer tokens with jose: asymmetric algorithm allowlist, issuer, audience, lifetime and clock skew, and cached JWKS with configurable timeouts. Requests without a Bearer header are left anonymous for other handlers and anonymous operations.
Arc.TypeScript (Arc for TypeScript 0.11.0 — authorization policies and identity): microsoftIdentityPlatform() authenticates callers from Azure App Service and Container Apps authentication headers (x-ms-client-principal, -id, -name), stripping caller-supplied identity claims the same way Arc on .NET does. It only reads these headers when you register it.
Arc.TypeScript (Arc for TypeScript 0.11.0 — authorization policies and identity): @identityDetailsProvider() lets discovery find the identity details provider, as Arc on .NET does, and model-bound identity details types describe /.cratis/identity-details/schema.
Arc.TypeScript (Arc for TypeScript 0.10.0 — ESLint rules for Arc artifacts): @cratis/eslint-plugin-arc-core for ESLint 10 flat config, with a recommended config and a recommended-type-checked config for projects that lint with type information.
Arc.TypeScript (Arc for TypeScript 0.10.0 — ESLint rules for Arc artifacts): Rules that carry Arc on .NET’s diagnostic ids where the check applies to TypeScript: ARC0002, ARC0003, ARC0004, ARC0005, ARC0010, ARC0012, ARC0014, ARC0015 and ARC0019. Each id has a documentation page with the reason, a failing example and the fix, and every other .NET id is listed with why it does not apply.
Arc.TypeScript (Arc for TypeScript 0.10.0 — ESLint rules for Arc artifacts): TypeScript-specific rules for the decorator programming model: properties without @field, decorated declare fields, @inject tokens and @query descriptors that do not match the method’s parameters, decorators placed where they have no effect, artifacts that are not exported, and validators without a @validator(Target) target. An opt-in rule checks that query argument names match parameter names.
Arc.TypeScript (Arc for TypeScript 0.10.0 — ESLint rules for Arc artifacts): Arc decorators are recognized through their imports from @cratis/arc.core and @cratis/fundamentals, including aliased and namespace imports, so decorators with the same names from other libraries are not reported.
Screenplay (Release v4.29.0): A policy with a csharp body or a file binds as an opaque policy-predicate attachment with a stable requirement id and the capability pure (SemanticOpaquePolicyCondition). A model that has one is ESM v3, like models with reducer bodies or code validation; other models keep their bytes.
Screenplay (Release v4.29.0): SemanticExecutionCapability.Authorization, reported when authorization cannot be decided without running policy code.
Screenplay (Release v4.29.0): PLAY0440: a policy combines require with an inline code block or a file. A policy has one form or the other.
Screenplay (Release v4.29.0): PLAY0441: a policy has more than one require line. Combine the conditions with and/or in one require.
Screenplay (Release v4.29.0): Proposed decision record 0005: policy predicates as an implementation-attachment role, and authored-order composition.
Stage (Release v4.12.0): A planned artifact now names the semantic identities it realizes: PlannedArtifact.Sources is a sorted, distinct list of slice, command, event, read-model, projection, query, concept, type and specification ids. Scaffold artifacts have no sources. Artifact bytes and SHA-256 hashes are unchanged, so a render plan maps every artifact to both its semantic origin and its hash. (#11)
Arc.TypeScript (Arc for TypeScript 0.9.0 — testing scenarios): CommandScenario.for(RegisterAuthor) runs a decorated command through the real pipeline (authorization, validation, provide(), handle()) with services you override (scenario.services.addSingleton/addScoped/addTransient), a principal, tenant and context values, and a serialization round trip through the wire format by default. execute(...) and validate(...) return results with assertions such as shouldBeSuccessful(), shouldHaveValidationErrors(), shouldHaveValidationErrorFor(message), shouldHaveValidationErrorForMember(member), shouldNotBeAuthorized() and shouldHaveExceptions().
Arc.TypeScript (Arc for TypeScript 0.9.0 — testing scenarios): QueryScenario.for(ReadModel, 'method') performs a @query method with arguments, paging and sorting through the real query pipeline.
Arc.TypeScript (Arc for TypeScript 0.9.0 — testing scenarios): ObservableQueryScenario collects emissions from an observable query within one explicit deadline and reports whether the stream completed.
Arc.TypeScript (Arc for TypeScript 0.9.0 — testing scenarios): shouldHaveValidationErrors() refuses to pass when the only failures come from unavailable dependencies or failing validators, so a misconfigured test cannot pass for the wrong reason.
Arc.TypeScript (Arc for TypeScript 0.8.0 — MongoDB integration): builder.addMongoDB({ server | client | serverResolver, database | databaseNameResolver, ... }), or the standalone addMongoDB(builder, options) function. Tenants get their own database (tasks, tasks+acme), and a server resolver can route tenants to different MongoDB servers.
Arc.TypeScript (Arc for TypeScript 0.8.0 — MongoDB integration): mongoCollection(Model) injects a tenant-scoped collection for a read model into a @query, with typed find, queryPage, observe and observeById.
Arc.TypeScript (Arc for TypeScript 0.8.0 — MongoDB integration): A metadata-driven BSON codec that reads and writes documents the way Arc on .NET does: @key() or id as _id, Guids as UUID binary (subtype 4), concepts as their primitive values, DateOnly, TimeOnly, TimeSpan and Date in .NET’s formats, nested models and arrays, and @derivedType discriminators in _derivedTypeId.
Arc.TypeScript (Arc for TypeScript 0.8.0 — MongoDB integration): Naming policies: defaultMongoNamingPolicy matches an unconfigured .NET MongoDB builder, and camelCaseMongoNamingPolicy matches .WithCamelCaseNamingPolicy(). Custom policies are supported.
Arc.TypeScript (Arc for TypeScript 0.8.0 — MongoDB integration): queryOptions() gives a query Arc’s paging and sorting options, and queryPage pushes them down to MongoDB with a count, a page-size cap and a field allowlist. An unknown sort field answers 400.
Arc.TypeScript (Arc for TypeScript 0.8.0 — MongoDB integration): observe(filter?) and observeById(id) turn MongoDB change streams into Arc observable queries, with a current value for plain GET and updates over SSE and WebSocket. Replica sets and sharded clusters are supported; a standalone server is rejected with a clear error.
Stage (Release v4.11.0): Render read-model and query specifications over read models built by scoped projections. Generated specifications replay every produced event in command order through the generated projection, including joins and removals. Replays that cannot be reproduced exactly fail with STAGE-ESM-011. (part of #14)
Stage (Release v4.11.0): Render complete given read models in query-only lookup specifications. Given read models before a command are still rejected. (part of #14)
Stage (Release v4.11.0): Render then events in any order with several events as a multiset match, checking each event’s stream and payload. (part of #14)
Arc.TypeScript (Arc for TypeScript 0.7.0 — command context, response handlers and operations): Command response value handlers: implement CommandResponseValueHandler (canHandle and handle) and register it or let discovery find it. Every handler that can handle a value returned from handle() processes it, in a deterministic order, and a handler failure stops the rest. At most one value left unhandled becomes the client response; more than one fails the command.
Arc.TypeScript (Arc for TypeScript 0.7.0 — command context, response handlers and operations): CommandContext for each command execution, carrying the command, its key, context values, correlation id, principal, tenant, allowed severity and cancellation signal. Context value providers and modifiers can add to it.
Arc.TypeScript (Arc for TypeScript 0.7.0 — command context, response handlers and operations): Command operations: handle() can return operations (and operation batches) that are checked before any runs, executed in order, and compensated in reverse order within a timeout when the command fails before anything commits. Execution scopes report an explicit commit disposition, an unknown commit outcome is reported as indeterminate rather than success, and recovery details stay on the server. Operations are rejected from nested commands and from commands that ran nested commands, so every effect stays inside one recovery boundary.
Arc.TypeScript (Arc for TypeScript 0.6.0 — proxies from TypeScript source): arc-proxygenerator --project <tsconfig> --artifacts <folder> --output <folder> reads your TypeScript program with the compiler API, without running your application, and writes proxies for the published @cratis/arc and @cratis/arc.react clients: commands with use() hooks, snapshot and observable queries with parameters, paging, sorting, use, useWithPaging, useSuspense and when, models, enums and derived types.
Arc.TypeScript (Arc for TypeScript 0.6.0 — proxies from TypeScript source): Command and query result types come from the return types of handle() and @query methods, so nothing is declared twice. Field optionality, nullability, defaults and enums come from the same @optional(), @nullable(), @defaultValue() and @enumeration() annotations the server uses.
Arc.TypeScript (Arc for TypeScript 0.6.0 — proxies from TypeScript source): Client-safe validation rules from @validator(Target) classes are generated into the proxies. Rules the browser cannot evaluate stay on the server and are reported by the generator.
Arc.TypeScript (Arc for TypeScript 0.6.0 — proxies from TypeScript source): Routes and query names come from the same discovery walk and route rules the server uses, with --root-namespace, --segments-to-skip, --api-prefix, --skip-command-name-in-route and --skip-query-name-in-route options named after the .NET generator’s settings.
Arc.TypeScript (Arc for TypeScript 0.6.0 — proxies from TypeScript source): Output management like .NET’s generator: ownership headers with content hashes, unchanged files left untouched, stale generated files and barrels removed, hand-written files and barrel lines preserved, plus --use-proxy-file-suffix, --emit-interfaces, --skip-index-generation, --skip-output-deletion and --js-import-specifiers.
Chronicle.TypeScript (Release v6.5.0): readModels.findInstanceById(type, id) returns null when no instance exists, so callers can tell a missing read model from an empty one.
Chronicle.TypeScript (Release v6.5.0): EventSequenceNumber.beforeFirst for expressing “no events appended yet” as an expected sequence number in a concurrency scope.
Chronicle.TypeScript (Release v6.5.0): isRegisteredEvent(store, value) tells whether a value is an instance of an event type registered with an event store.
Chronicle.TypeScript (Release v6.5.0): Scoped run methods on the identity, causation and correlation managers, so concurrent or nested operations on a server each keep their own ambient context and restore the previous one afterwards.
Stage (Release v4.10.0): The semantic specification engine (--engine semantic) now runs specifications with a given caller, command authorization and then denied. Denied specifications check that nothing was appended. (part of #15)
Stage (Release v4.10.0): It evaluates command validation rules and requirements at every severity, matching Screenplay’s rule order, messages and default messages, and enforces unique-value and unique-event constraints, including releases, casing and re-claiming one’s own value. A constraint rejection carries the constraint name as its code. (part of #15)
Stage (Release v4.10.0): when append specifications that assert only events now run. (part of #15)
Stage (Release v4.9.0): Render portable unique <property> on <Event> and unique event <Event> constraints as named Chronicle constraints, with every target, release, casing rule and message. Generated specifications prove violations, releases, casing and re-claiming one’s own value. Constraints on optional, composite or non-text properties, and several events from one command that target or release a unique-value constraint, still fail with STAGE-ESM-014. Chronicle updates its constraint index after commit (Cratis/Chronicle#4123), so a storage failure there is not rejected at append time. (#118)
Stage (Release v4.9.0): Commands that produce several unconditional events render, and generated specifications assert each event on its stream in order. A specification may now expect several read models and query results. (part of #14)
Stage (Release v4.9.0): Specifications with a given caller fixture and then denied now render. The caller runs through Arc’s principal override, and a denied specification checks that the command was unauthorized, that the policy is registered, and that nothing was appended. Protected-query expectations and claim conditions on the role claim type are still rejected. (part of #57)
Stage (Release v4.9.0): Render nested from and clear blocks, supported every event-source mappings, and root and child RemovedWith / RemovedWithJoin. A differential specification now runs admitted projection shapes through Chronicle and compares the results with Screenplay’s reference execution. (part of #117)
Arc.TypeScript (Arc for TypeScript 0.5.0 — model-bound commands, read models and validators): Model-bound commands: a class decorated with @command() declares its input with Fundamentals @field(Type) and handles itself in handle(). An optional provide() loads data after validation and passes it to handle(), or short-circuits with rejected(...) / denied(...).
Arc.TypeScript (Arc for TypeScript 0.5.0 — model-bound commands, read models and validators): Model-bound read models and queries: a class decorated with @readModel() exposes static @query(...) methods. argument(name, Type) and service(Token) describe the parameters in order, and @query({ observable: true }) serves live results over the same snapshot, SSE, WebSocket and hub transports as defineObservableQuery.
Arc.TypeScript (Arc for TypeScript 0.5.0 — model-bound commands, read models and validators): Concepts from @cratis/fundamentals (ConceptAs<T> with static readonly valueType) on the wire: requests decode into concept, Guid, Date, DateOnly, TimeOnly and TimeSpan values and responses encode back to primitives. Invalid values answer 400 with malformedRequest.
Arc.TypeScript (Arc for TypeScript 0.5.0 — model-bound commands, read models and validators): Validators with the same vocabulary as the @cratis/arc client: CommandValidator<T>, QueryValidator<T>, ConceptValidator<T> and ModelValidator<T> declare rules with ruleFor(...) (notEmpty, maxLength, emailAddress, greaterThan, must, mustAsync, when, unless, withMessage, withSeverity, withState and more) and are bound to their target with @validator(Target). Concept validators apply wherever the concept appears, member paths use client casing, and validators are created per execution scope.
Arc.TypeScript (Arc for TypeScript 0.5.0 — model-bound commands, read models and validators): Authorization decorators @roles(...), @authorize() and @allowAnonymous() on commands, read models and query methods. A method declaration overrides its class, stacked declarations must all pass, and contradictory declarations fail at startup.
Arc.TypeScript (Arc for TypeScript 0.5.0 — model-bound commands, read models and validators): @path(...) to override a query route, and generatedApis options (routePrefix, segmentsToSkipForRoute, includeCommandNameInRoute, includeQueryNameInRoute) for conventional routes derived from the folder a command or read model lives in, matching Arc on .NET.
Arc.TypeScript (Arc for TypeScript 0.5.0 — model-bound commands, read models and validators): Dependency injection with classes as service tokens: builder.services.addSingleton/addScoped/addTransient(Token, implementation?), @singleton(), @scoped(), @transient(), @injectable(...) and @inject(...). Both TC39 standard decorators and legacy experimentalDecorators with emitDecoratorMetadata are supported; in legacy mode @inject() can read parameter types.
Arc.TypeScript (Arc for TypeScript 0.5.0 — model-bound commands, read models and validators): ArcApplication.createBuilder(options) with discover(folder) and add(...), build(), a blocking run() that shuts down on SIGINT or SIGTERM, and start() / stop() for embedding. Express, Fastify and Hono mounts accept
Stage (Release v4.8.0): Run Screenplay specifications in memory against the executable semantic model with SpecRunner’s opt-in --engine semantic. It addresses specifications by semantic id through --specification and --scope, and writes a stage-spec-run/1 report. A specification the engine cannot execute exactly is reported Unsupported with a typed capability before it runs, so it is never reported as passing; there is no Inconclusive outcome. The default structural engine is unchanged. (part of #15)
Stage (Release v4.8.0): Cratis.Stage.Specifications provides ISemanticSpecificationExecutor, and Cratis.Stage.Contracts provides the semantic run report and a .play source loader. Commands run through Arc’s command scenario against a fresh in-memory Chronicle event log for each specification. Results are checked against Screenplay’s reference runner on the canonical corpus. (part of #15)
Screenplay (Release v4.28.0): AttachmentFiles.Load(root, documents) reads the files named by a model’s implementation attachments (reducer rules, validation rules and code validation, command handlers, policies, reactions, query performers, file constraints) from a model root and returns their contents with warning diagnostics for anything it refuses. Pass Contents to SemanticDocumentSet.Create(documents, catalog, contents).
Screenplay (Release v4.28.0): ScreenplayWorkspace.WithAttachmentContents(contents, diagnostics) and a matching ScreenplayWorkspace.Create overload carry host-supplied contents through every workspace compilation, proposal and transaction. The workspace itself never reads files, and its revision and serialized bytes do not depend on attachment contents.
Screenplay (Release v4.28.0): PLAY0430–PLAY0434 warnings for an attachment that is refused or missing: a path that is absolute or leaves the model root, a link, a missing file, a file over 2 MiB (or a set over 8 MiB), and content that is not UTF-8 text. A refused attachment stays unresolved; it never fails a model that compiled before.
Stage (Release v4.7.0): Render portable Screenplay policies for commands and queries as registered Arc authorization policies, including module- and feature-level authorize. A command or query is [AllowAnonymous] only when no authorization applies. Expressions Arc would enforce differently fail with STAGE-ESM-015: role-only or claim-only policies that do not require authentication, ambiguous command subjects, and non-text claim targets. (part of #57)
Stage (Release v4.7.0): Render all thirteen ESM validation rule kinds, concept validation rules and command requirements as generated validators, with the reference default messages. Warning and information severities, $strings. messages, and combinations whose failure order Arc cannot preserve are still rejected. (part of #116)
Stage (Release v4.7.0): Render ESM projection scopes: several from events, root joins, children identified by a property, and property and arithmetic mappings. Several read models and keyed queries in one state-view slice are now admitted. Nested blocks, every/all, removals, composite keys, event-context mappings, whole-number arithmetic, and scopes that leave a required property unset fail with STAGE-ESM-017. (part of #117)
Stage (Release v4.7.0): Render given events that state their event source in generated command, read-model and query specifications. Read-model and query assertions without exactly now check only the stated properties, as the reference does, and query specifications check projected state. (part of #14)
Stage (Release v4.7.0): Generated rejection specifications now check the first validation message against the modeled then error.
Screenplay (Release v4.27.0): A named rule with a csharp body or a file on a command property or a concept (invoiceNumber rule BeUnusedInvoiceNumber file Validations/BeUnusedInvoiceNumber.cs), and a command’s validate csharp block, bind as opaque rule-predicate and code-validation attachments. Each carries what it guards, its message (including $strings keys) and severity, a stable requirement id and the capability pure. A bare named rule with neither body nor file is still rejected.
Screenplay (Release v4.27.0): SemanticCodeValidation, SemanticCommand.CodeValidations, SemanticValidationRule.Name and SemanticValidationRule.RequirementId, and the SemanticValidationRuleKind members RulePredicate and CodeValidation.
Components (Release v4.14.0): Column.filterOptions supplies the values a column can be filtered by, rendered as a list instead of a free-form input, with the match modes narrowed to equals/not equals.
Components (Release v4.14.0): selectionMode='multiple' on the data tables and DataPage, with a checkbox per row, a select-all header checkbox, and selectedItems/onSelectedItemsChange.
Components (Release v4.14.0): dataTable.selectAllRows message for localizing the select-all accessible name.
Screenplay (Release v4.26.0): A reducer whose every on <Event> rule has a body, inline or in a file, binds to a reducer contract in the executable semantic model: the read model it builds, the events it consumes, a key fixed to the event source id, no initial state, and a result that is the new state or a delete, as Chronicle runs reducers. Inline and file bodies bind to the same contract. The body stays opaque code, not portable meaning.
Screenplay (Release v4.26.0): ESM v3. A model is serialized as v3 only when it contains a bodied reducer; every other model keeps its v1 or v2 bytes exactly. v3 includes all of v2. LanguageVersion.V3, SemanticVersion.V3 and EsmSchemaV3Support describe it, and a full v3 golden vector pins its canonical form. Reducer transitions are canonicalized by event, so reordering on rules does not change a model’s revision.
Screenplay (Release v4.26.0): Implementation requirements carry RequirementId (derived from the owning construct, role and member, never from a path), ContextVersion and ResultVersion, RequiredCapability (pure for reducer transitions) and AttachmentResolution.
Screenplay (Release v4.26.0): SemanticDocumentSet.Create(documents, catalog, attachmentContents) lets a host supply the contents of file attachments, which are then identified by a hash of their content. Without supplied contents a file attachment is reported as UnresolvedFile with no hash; the file compiler, MCP server and Tool supplying contents is tracked in #244.
Screenplay (Release v4.26.0): PLAY0398: a reducer mixes rules with and without a body.
Screenplay (Release v4.26.0): PLAY0399: a reducer has more than one rule for the same event.
Screenplay (Release v4.25.0): reads <View> as <alias> [by <property>] names a read, so a command can read the same view twice, for example reads Account as source by fromId and reads Account as destination by toId. A require path can use the alias as its qualifier: require source.balance >= amount.
Screenplay (Release v4.25.0): PLAY0410: a command reads the same view more than once and not every read has an alias.
Screenplay (Release v4.25.0): PLAY0411: two reads of one command use the same alias.
Screenplay (Release v4.25.0): PLAY0412: a reads alias has the same name as one of the command’s properties.
Screenplay (Release v4.25.0): ReadsSyntax.Alias, an init-only property, carries the alias in the syntax tree, syntax JSON, the printer, the TextMate grammar and the Monaco language package (completion, keyword docs, symbols).
Arc.TypeScript (Arc for TypeScript 0.4.0 — observable queries and the Arc package layout): Observable queries with defineObservableQuery: sources can be async iterables, RxJS-style observables or CurrentValueSubject.of(value) / .pending(). Every subscription runs the query’s authorization and validation and owns a service scope.
Arc.TypeScript (Arc for TypeScript 0.4.0 — observable queries and the Arc package layout): Direct server-sent events and WebSocket streams on a query’s own route, and the multiplexed /.cratis/queries/ws and /.cratis/queries/sse hubs used by the @cratis/arc client, with subscription revisions, full and delta transfer modes, and keep-alive.
Chronicle.TypeScript (Release v6.4.0): Declare event types, read models, projections, reducers, reactors and the other SDK artifacts with TC39 standard decorators, without enabling experimentalDecorators. Legacy decorators keep working.
Chronicle.TypeScript (Release v6.4.0): Schema support for explicitly typed arrays and for Guid-, Date-, and primitive-backed concepts, with a static readonly valueType hint for concepts when no decorator type metadata is emitted.
Stage (Release v4.5.0): Admit ESM v2 models from Screenplay 4.20. A command with a typed produces … for destination appends to that event source without copying the identity into the event. When a specification states for <value> on its when or then event, the generated specification checks the appended event on that stream. It also seeds the projected read model there. (#128)
Screenplay (Release v4.24.0): A workspace transaction that finds two files declaring the same thing returns a typed ConflictingOwner conflict naming both paths, instead of a generic compilation failure. Ownership belongs to the file that declares a member, never to a module or feature header restated to place a child (#137)
Screenplay (Release v4.24.0): Specs pin the round trip of a commented model between a single document and a folder: same semantic revision, same identities, same canonical print, and every comment kept. A folder write is rejected before touching disk when the source changed since the proposal (#137)
Screenplay (Release v4.23.0): when append <Event> specifications: the event goes through append-time constraints and projections, then the stated read models and query results are compared. If the specification asserts events, they must equal the complete set of new facts. Reactions do not run.
Screenplay (Release v4.23.0): Explicit comparison qualifiers on specification outcomes. Event order defaults to authored order and can be relaxed; read-model and query properties default to subset matching and can be made exact. Conflicting actions and malformed qualifiers are reported (PLAY0358, PLAY0359).
Screenplay (Release v4.23.0): An inventory of the code attachments the executable model cannot run yet: command handlers and validation, concept validation, rule and policy predicates, reducer transitions, query performers and reactions. Each is listed with its role, owning declaration, language or file, content hash and source location. It sits on the compilation result, and MCP pages it by workspace revision. Binding still fails closed with PLAY0268.
Screenplay (Release v4.23.0): A policy may name its implementation with file <Path>, as an alternative to inline code. The executable model treats it like a code policy.
Screenplay (Release v4.22.0): Declarative policies bind into the executable semantic model and are evaluated for commands and queries. A command’s or query’s effective authorization is its own policies, every enclosing feature’s and its module’s, combined by AND (#142)
Screenplay (Release v4.22.0): Specifications accept a given caller block (authenticated, role "<role>", claim "<type>" = "<value>"; a claim may repeat) and a then denied outcome, distinct from then error. A denied command or query is rejected as Unauthorized before validation runs (#142)
Screenplay (Release v4.21.0): Modules and features accept authorize. It combines by AND with the policies of every command and query beneath them, and folder files merge it like behaviors; a repeated identical clause warns with PLAY0394 (#75)
Screenplay (Release v4.21.0): Inline code blocks carry their language as a fence info string (```csharp). The previous forms — a language line above a bare fence, and validate csharp — still parse with a PLAY0397 warning, and printing writes the new form (#184)
Screenplay (Release v4.21.0): Typed accessors beside every dynamic context member (CommandAs<T>(), ArgumentsAs<T>(), ArtifactAs<T>(), …), so LINQ in inline code binds at compile time. A payload of another type throws ContextPayloadTypeMismatch (#84)
Screenplay (Release v4.21.0): Canonical corpus vectors: RegisterProject with reordered and relocated documents (same revision and bytes), a pinned ESM v2 vector, and an unsupported vector that fails closed with no artifacts. The corpus package now runs package validation (#168)
Screenplay (Release v4.21.0): Documentation gates: every construct the parsers accept must have a grammar production and a reference page; every relative link and anchor must resolve and every page must be reachable from navigation. Documentation-only pull requests now run these checks (#146)
Arc.TypeScript (Arc for TypeScript 0.3.0 — generated clients): exportClientManifest writes a versioned JSON client manifest from registered commands and queries that declare an explicit clientOutput shape.
Arc.TypeScript (Arc for TypeScript 0.3.0 — generated clients): @cratis/arc.server.codegen renders @cratis/arc command and query proxies from that manifest, with renderClientManifest, generateClient, and a JSON-only CLI that refuses unsafe paths, symlinks, and overwrites of files it does not own.
Arc.TypeScript (Arc for TypeScript 0.3.0 — generated clients): Generated proxies for flat DTOs, basic and optional inputs, command responses, and DTO or array queries, verified against live Express, Fastify, and Hono hosts with the published @cratis/arc client.
Screenplay (Release v4.20.0): Executable semantic model version 2. It is selected automatically when a model uses a v2 construct and is otherwise unchanged at version 1 (#226, #167):
Screenplay (Release v4.20.0): Typed state-change destinations: produces … for <expr> targets an event source without duplicating the identity into the event.
Screenplay (Release v4.20.0): Event-source context on facts, which projections read the event-source identity from.
Screenplay (Release v4.20.0): for <value> event-source assertions on given and then events, so a specification can name exact streams. For example, a unique constraint can be shown colliding between two event sources.
Screenplay (Release v4.20.0): $context.occurred and the caller’s identity ($context.identity.*) in produces, matching Chronicle’s event context.
Screenplay (Release v4.20.0): Projection variants execute. Each variant is its own read model; entering one removes the entity from its siblings, and projection-level handlers apply to every variant that has the property. This follows how Chronicle’s variant support reclassifies them. New errors (PLAY0382–PLAY0385) cover a variant without enters on, an entering event claimed twice, and a shared mapping a variant’s read model lacks (#185)
Screenplay (Release v4.20.0): Validation rules and require conditions accept a severity: information, warning or error (the default). Every failing rule still rejects the command, and the rejection reports each failure’s severity (#227)
Arc (Release v22.23.0): Register scoped, asynchronous authorization policies with IAuthorizationPolicy and AddArcAuthorizationPolicy<TPolicy>() on either Arc host (#2736).
Arc (Release v22.23.0): Use ASP.NET Core policies and authentication schemes on model-bound commands, queries, and observable subscriptions, following the authorization contract (#2736).
Arc.TypeScript (Arc for TypeScript 0.2.0 — services and identity): Explicit service tokens and singleton, scoped, and transient lifetimes, with owned resource cleanup and real-pipeline testing helpers.
Arc.TypeScript (Arc for TypeScript 0.2.0 — services and identity): Registry-owned singleton initialization and graceful draining of admitted work without converting committed successes into shutdown failures.
Arc.TypeScript (Arc for TypeScript 0.2.0 — services and identity): Explicit trusted native-principal integration for Express, Fastify, and Hono, with native TLS handling and preserved routing defenses.
Arc.TypeScript (Arc for TypeScript 0.2.0 — services and identity): Ordered tenant selection with optional required-tenant and membership enforcement, plus opt-in development user and tenant discovery.
Arc.Kotlin (Release v7.6.0): Opt into Name.proxy.ts filenames with cratisArc.proxies.useProxyFileSuffix or --use-proxy-file-suffix true. Generated imports and barrel exports follow the setting, while external mappings and routes stay unchanged. Switching either direction cleans up owned generated files when cleanup is enabled (#229).
Arc.TypeScript (Arc for TypeScript 0.1.0 — source preview): Schema-backed command and query APIs with validation-only execution, authorization, tenant and correlation context, execution scopes, and paging.
Arc.TypeScript (Arc for TypeScript 0.1.0 — source preview): Introspection, basic OpenAPI descriptions, a runnable Tasks sample, and documentation of supported capabilities and limitations.
Screenplay (Release v4.19.0): Specification values accept typed single-line objects and lists, such as lines = [{"sku":"A-1","quantity":2}] and tags = []. Keys are checked against the declared composite type (PLAY0291–PLAY0294). The values bind to executable composite and array values and run end to end (#215, #207)
Screenplay (Release v4.19.0): Specifications may state a subset of read-model or query-result properties. A query result may omit the identifier its arguments supply. Specifications with only given and then query/then readmodel steps and no when run (#207)
Screenplay (Release v4.19.0): Commands can produce events conditionally (produces when …) with conditions over command properties, and can state require conditions over command properties. Each condition is evaluated independently (#210, #209)
Screenplay (Release v4.19.0): Literal tags on events and produces travel as append metadata (#210)
Screenplay (Release v4.19.0): Constraints accept released by <Event>, composite properties (unique a, b on E), several targets under one name, message and ignore casing (#212)
Screenplay (Release v4.19.0): matches "<regex>" takes an ECMAScript regular expression, and matches email is a named pattern with a documented definition (#209)
Screenplay (Release v4.19.0): Renaming a composite type’s property through MCP rewrites the object keys that name it (#215)
Stage (Release v4.2.0): Customize generated hosts through optional ConfigureServices and ConfigureApplication hooks and a Customizations/Dependencies.props import, without editing managed files. Includes a catalog adapter example and a customization guide. Modeled capture, reaction, and file bindings remain unsupported. (#121)
Stage (Release v4.2.0): Load an optional product-owned Customizations/styles.css after component tokens and styles, before rendering the frontend. The renderer never emits files into this directory. (#122)
AI (Release v3.4.0): The social feed post skill now teaches drafting in a human voice: open with something that happened or the reader’s concrete problem, talk the way the people who built it would, show the default shape next to the better one, sell with specifics instead of adjectives, put each limit inside the sentence it limits, keep review and evidence language out of the copy, and stop when you are done.
AI (Release v3.4.0): The voice and cadence skill recognizes five more tells of generated prose: punchline fragments (“They run.”), signpost pairs (“That’s the X. Here’s the Y.”), labeled caveats (“One honest limit:”), aphoristic closes and reflexive triplets.
AI (Release v3.4.0): The voice and cadence skill explains hedged, noncommittal copy as review language leaking into the material, and how to fix it without dropping a true limitation.
Stage (Release v4.1.0): Support scalar nested objects, all-event subscriptions, and recursive projection definitions when loading Screenplay models. (#125)
Screenplay (Release v4.18.0): The executable semantic model admits validation rules beyond not empty: max/min (length on text, value on numbers), ==/!=, >/>=/</<= on numbers, length ==, and all >/all >= over collections of numbers. The reference executor evaluates them all (#209)
Screenplay (Release v4.18.0): The executable semantic model admits every projection block the way Chronicle lowers it: several events in one from, children, nested, update-only join, every/all, remove with, remove via join, composite and literal keys, and the add/subtract/increment/decrement/count/clear mappings. The reference executor runs them all (#211)
Screenplay (Release v4.18.0): The executable semantic model admits unique <property> on <Event> and unique event <Event> constraints, and the reference executor enforces them with Chronicle’s semantics (#212)
Screenplay (Release v4.18.0): One event-context catalog, matching Chronicle’s EventContext, is shared by the compiler, the editor and the documentation. The compiler checks $eventContext paths against it (PLAY0295–PLAY0299) and the editor underlines invalid paths (#217)
Screenplay (Release v4.18.0): MCP read-proposal has a dropped-comments view, and every proposal reports how many comments it drops (#216)
Screenplay (Release v4.18.0): A workspace operation replaces one produced-event mapping source in place (#193)
Screenplay (Release v4.18.0): PLAY0290: an import names something the application declares itself (#208)
Screenplay (Release v4.18.0): PLAY0340: the same behavior is attached twice across folder files
Screenplay (Release v4.18.0): PLAY0380: Chronicle’s projection lowering drops part of a construct
Screenplay (Release v4.18.0): PLAY0381: a projection-level key does not route events
AI (Release v3.3.0): A hook guards agent-run cratis chronicle commands in Claude and Pi: read-only inspection and help run as before; replay, retry, quarantine clearing, job control, recommendations, and adding or removing users, applications and subscriptions are refused, as is any chronicle command the guard does not recognize.
AI (Release v3.3.0): A human who has authorized a store mutation can allow it by starting the agent with CRATIS_HOOKS_ALLOW_STORE_MUTATIONS=1; the command lists live in cratis-store-mutations.json and can be extended per repository.
Arc (Release v22.22.0): CratisProxiesUseProxyFileSuffix names generated TypeScript files Name.proxy.ts instead of Name.ts, so generated proxies can be told apart from hand-written TypeScript in the same folders. Imports between generated files and index.ts barrels follow the suffix; imports of modules you mapped yourself are left as mapped. Switching the option on or off replaces the previously generated files. Off by default.
Chronicle (Release v19.4.5): CHRONICLE_MONGODB_IMAGE selects the MongoDB image the integration fixtures start. Current MongoDB refuses to start on some host kernels, and the refusal surfaces as a container start timeout that explains nothing, leaving integration scenarios unrunnable on that machine.
cli (Release v3.16.0): Shell completions offer the AI and LLM command values offline, without calling out to a provider.
cli (Release v3.15.0): cratis llm-context now gives every command an effect — read-only, local, mutating or destructive — and a requiresConfirmation flag, so agents and guards can tell observing commands from state-changing ones without keeping their own lists.
cli (Release v3.15.0): The cratis llm-context --schema JSON Schema, the catalog’s tips, the generated CHRONICLE.md safety notes and a new LLM Context reference page explain both fields and what each value means.
cli (Release v3.14.0): cratis run accepts a single Screenplay (.play) file as well as a folder. Only that file is mounted, read-only, and handed to the Stage; the folder it sits in is not mounted (#128)
Chronicle.Mcp (Release v1.4.0): Every tool declares MCP tool annotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint), so MCP clients can run read-only tools freely and ask before a tool changes state. stop_job and resume_job are state-changing, non-destructive and idempotent; delete_job is state-changing, destructive and idempotent; all other tools are read-only, and every tool is closed-world — it talks only to the configured Chronicle server. (#34)
Arc (Release v22.21.0): Analyzer ARC0021 reports a Policy or AuthenticationSchemes on an authorization attribute of a model-bound command or read model. Arc enforces authentication and roles but evaluates neither of these, so the artifact is less protected than its attribute reads (#2736)
Arc (Release v22.21.0): IAuthorizationAttributeEvaluator.GetAuthorizationRequirements, so an evaluator can report every attribute it finds. It defaults to the existing single answer, so existing implementations keep working
AI (Release v3.2.1): The Decision Engine image is built and pushed to Docker Hub with every release, as cratis/decision-engine
AI (Release v3.2.0): IDecisions — submit context plus a finite set of choices, get back every choice with its probability, the highest-probability choice, and the margin to the runner-up. Thresholds are deliberately left to consumers so the raw distribution survives intact (#392)
AI (Release v3.2.0): A batch overload on IDecisions for callers scoring many candidates against one task, with results guaranteed in request order (#392)
AI (Release v3.2.0): Decision as an AIProviderCapability and an AIModelCapability, advertised independently of the conversational and agentic capabilities (#392)
AI (Release v3.2.0): AIProviderType.DecisionEngine and AddDecisionEngineProvider / ReconfigureDecisionEngineProvider for configuring decision providers the same way as any other AI provider (#392)
AI (Release v3.2.0): AIModelCapabilities.For(AIProviderType, ModelName) — capability for a decision model is declared by provider type rather than inferred from the model identifier, which carries no marker that would distinguish it from a chat model (#392)
AI (Release v3.2.0): AIProviderCapabilities — what each provider type can be used for. A decision engine advertises Decision and neither Conversational nor Agentic, so existing compatibility checks refuse to schedule an agent onto it (#392)
AI (Release v3.2.0): AddCratisAI(ai => ai.WithDecisions<TResolver>()) registers the decision surface. Nothing decision-related is registered when it is not called (#392)
AI (Release v3.2.0): Telemetry on Cratis.AI.Decisions: decision duration, count, and top-probability distribution. Context text is not recorded unless explicitly enabled (#392)
AI (Release v3.2.0): The Cratis Decision Engine service under Source/DecisionEngine/ — Decision API v1, CPU-first, model and calibration temperature configurable, with an artifact cache so restarts do not re-download weights (#392)
release-action (Release v1.4.0): The issues a release’s notes say it resolves are closed when the release is created, each with a comment naming the release tag. Only a note bullet ending in (#123) counts; prose mentions and cross-repository references are left alone. Needs issues: write, and is turned off with close-resolved-issues: false
Arc (Release v22.20.0): Analyzer ARC0019 reports [AllowAnonymous] declared on the same class or method as [Authorize] or [Roles]. Arc resolves that contradiction differently depending on evaluator order — rejecting the call in one order and admitting anonymous callers in the other — so the declaration now fails loudly at build time instead. Overriding a class on one query method is supported and not reported (#2714)
Arc (Release v22.20.0): Analyzer ARC0020 reports [Authorize] or [AllowAnonymous] from Microsoft.AspNetCore.Authorization on a model-bound [Command] or [ReadModel]. Arc enforces only its own Cratis.Arc.Authorization attributes on model-bound artifacts, so the ASP.NET Core attribute protects nothing: a command marked with it is open to every caller. Use the Arc attribute of the same name. Controller-based commands and queries are unaffected (#2719)
Chronicle.Elixir (Release v3.5.0): encrypted/1,2,3 macro (Chronicle.Confidentiality) for values that need encryption at rest without being personal data subject to GDPR right-to-erasure — an API key, a webhook signing secret, a partner credential (Cratis/Chronicle#4095)
Chronicle.Elixir (Release v3.5.0): Chronicle.Concept gets its own concept-level encrypted/0,1 macro, mirroring how pii/0,1 is the concept-level counterpart to Chronicle.Compliance.pii/1,2
Chronicle.Elixir (Release v3.5.0): EncryptionScope (:subject default, :namespace, :global) — the identity an encrypted value’s key is provisioned under. A subject-scoped key is always disjoint from any pii key for the same subject; a namespace-scoped key is shared by every value marked that way in one event store namespace; a global-scoped key is shared across the whole installation
Chronicle.Elixir (Release v3.5.0): pii and encrypted cannot both apply to the same value — rejected at schema-generation time with Chronicle.Confidentiality.PiiAndEncryptedCombinedNotSupported, because the two would otherwise encrypt the value twice under two different keys and be unable to release it correctly
Chronicle.Elixir (Release v3.5.0): encrypted/0,1 cannot be declared on a Chronicle.Concept created with event_source_id: true, rejected at compile time, mirroring the existing restriction on pii/0,1
Chronicle.Kotlin (Release v6.4.0): @Encrypted annotation (io.cratis.chronicle.confidentiality) for values that need encryption at rest without being personal data subject to GDPR right-to-erasure — an API key, a webhook signing secret, a partner credential (Cratis/Chronicle#4095)
Chronicle.Kotlin (Release v6.4.0): EncryptionScope.Subject (default), .Namespace, and .Global — the identity an @Encrypted value’s key is provisioned under. A subject-scoped key is always disjoint from any @Pii key for the same subject; a namespace-scoped key is shared by every value marked that way in one event store namespace; a global-scoped key is shared across the whole installation
Chronicle.Kotlin (Release v6.4.0): @Pii and @Encrypted cannot both apply to the same value — rejected at schema-generation time with PiiAndEncryptedCombinedNotSupported, because the two would otherwise encrypt the value twice under two different keys and be unable to release it correctly
Chronicle.Kotlin (Release v6.4.0): @Encrypted cannot be applied to an EventSourceId-typed concept, flagged with EncryptedNotSupportedOnEventSourceId, mirroring the existing restriction on @Pii
Chronicle.TypeScript (Release v6.3.0): @encrypted() decorator (@cratis/chronicle/confidentiality) for values that need encryption at rest without being personal data subject to GDPR right-to-erasure — an API key, a webhook signing secret, a partner credential (Cratis/Chronicle#4095)
Chronicle.TypeScript (Release v6.3.0): EncryptionScope.Subject (default), .Namespace, and .Global — the identity an @encrypted() value’s key is provisioned under. A subject-scoped key is always disjoint from any @pii() key for the same subject; a namespace-scoped key is shared by every value marked that way in one event store namespace; a global-scoped key is shared across the whole installation
Chronicle.TypeScript (Release v6.3.0): @pii() and @encrypted() cannot both apply to the same value — rejected at schema-generation time with PIIAndEncryptedCombinedNotSupported, because the two would otherwise encrypt the value twice under two different keys and be unable to release it correctly
Chronicle.TypeScript (Release v6.3.0): @encrypted() cannot be applied to the eventSourceId property, flagged at decoration time with EncryptedNotSupportedOnEventSourceId, mirroring the existing restriction on @pii()
Chronicle (Release v19.4.0): [Encrypted] attribute (Cratis.Chronicle.ProtectedValues) for values that need encryption at rest without being personal data subject to GDPR right-to-erasure — an API key, a webhook signing secret, a partner credential (#4095)
Chronicle (Release v19.4.0): EncryptionScope.Subject (default), .Namespace, and .Global — the identity an [Encrypted] value’s key is provisioned under. A subject-scoped key is always disjoint from any [PII] key for the same subject; a namespace-scoped key is shared by every value marked that way in one event store namespace; a global-scoped key is shared across the whole installation
Chronicle (Release v19.4.0): [PII] and [Encrypted] cannot both apply to the same value — rejected at schema-generation time, and flagged at compile time by a new analyzer (CHR0053), because the two would otherwise encrypt the value twice under two different keys and be unable to release it correctly
Chronicle (Release v19.4.0): [Encrypted] cannot be applied to an EventSourceId<T>, flagged at compile time by a new analyzer (CHR0052), mirroring the existing restriction on [PII]
Chronicle (Release v19.4.0): No API anywhere can delete an [Encrypted] value’s key — PIIManager’s erasure operations explicitly refuse an identifier belonging to an [Encrypted] value
Chronicle (Release v19.4.0): Cratis.Chronicle.Testing’s EventScenario and related scenario helpers now protect [Encrypted] values the same way they already protect [PII] values
Chronicle (Release v19.4.0): Cratis.Chronicle.Confidentiality — a security metadata provider system (ICanProvideSecurityMetadataForType/ICanProvideSecurityMetadataForProperty, ISecurityMetadataResolver) parallel to the existing GDPR compliance one, for classifying a value as needing protection for security reasons rather than compliance reasons. [Encrypted] is its first consumer; [PII] continues to resolve only through the compliance provider system and never gains [Encrypted]’s wider scopes
AI (Release v3.1.2): A Cratis site reference for the documentation writing skill: which teaching components to use (YouWillLearn, Recap, client-language tabs), how to state an experimental product’s maturity, how to state cross-product compatibility, what Prompter records as a documentation-gap signal, and who decides page structure.
cli (Release v3.12.0): Render generated applications with explicit command inputs and editable keyed lookups using Stage 3.22.0.
Stage (Release v3.22.0): Compose exact required String/Guid command inputs and an explicit submit action; show unsupported required fields instead of silently omitting them. (#100)
Stage (Release v3.22.0): Generate editable lookup forms for supported optional-single queries alongside command forms, preserving exact entered identifiers and showing returned values or not-found states. (#100)
Stage (Release v3.22.0): Bind generated queries by stable source identity so ambiguous names are not silently resolved to another query. (#100)
Scene (Release v3.7.0): Let Scene command forms bind exact String and Guid inputs and submit through the native Arc form, showing unsupported required properties instead of silently omitting them. (#7)
Scene (Release v3.7.0): Rebind mounted forms when their registered command changes, so submissions use the current proxy and authorization. (#7)
AI (Release v3.1.0): Selecting the cratis/screenplay profile makes the Screenplay MCP server available through the Cratis CLI and each supported client’s native project integration. No separate Screenplay .NET tool installation or manual MCP JSON is needed.
AI (Release v3.1.0): Pi receives a native Screenplay tool bridge that discovers live tool schemas, honors profile selection and opt-out, and reports errors without retrying an uncertain source mutation.
AI (Release v3.1.0): Screenplay AI guidance now teaches scoped model navigation, reviewed typed-AST proposals, safe refactoring, durable identities and explicit recovery.
cli (Release v3.11.0): Run the Screenplay MCP server with cratis screenplay mcp, bundled into the Cratis CLI with no separate Screenplay tool installation or startup download.
cli (Release v3.11.0): Configure Screenplay MCP automatically when cratis ai install or cratis ai update selects the Screenplay profile, including profiles that compose it. Supported native configurations cover Claude Code, VS Code/Copilot, Cursor, OpenCode, Codex and Pi.
cli (Release v3.11.0): Choose a project-local model directory or disable registration in .cratis/ai.json; dry-run and status report the planned and installed registrations.
Components (Release v4.13.0): Let AutoCommandForm callers place optional footer content, including a native submit action, inside the form while retaining its fields-only default. (#314)
Screenplay (Release v4.16.0): Embed the Screenplay MCP server in .NET 10 hosts through the Cratis.Screenplay.Mcp package and ScreenplayMcpServer.Run, without installing or launching a separate tool. The existing screenplay mcp command remains supported with the same protocol and authoring behavior. (#203)
AI (Release v3.0.0): DayKey, the daily counterpart to WeekKey and MonthKey.
AI (Release v3.0.0): AgentUsageBucketKey, the day/provider/agent/purpose/model bucket a daily usage row accumulates under.
AI (Release v3.0.0): AgentSessionUsageRecorded now carries a precomputed DayKey and DailyBucketKey, for the reason its own remarks already give for WeekKey/MonthKey: Chronicle’s model-bound key resolution keys a projection on a single event property, so a composite bucket has nowhere else to come from.
AI (Release v3.0.0): UsagePeriod now carries the resolved Day and DailyBucket alongside Week and Month.
AI (Release v3.0.0): AgentSessionUsageRecorded and UsagePeriod gained required positional parameters. Code constructing either directly must supply them; RecordAgentSessionUsage.Provide resolves them for the normal path.
AI (Release v3.0.0): AgentUsageByDay’s shape and the signature of AgentUsageByDay.LastYear changed as described above.
Screenplay (Release v4.15.0): Author Screenplay models through screenplay mcp <model-folder> with typed AST creation and editing, guarded cross-file renames, and reviewable multi-file proposals. Install the server with the existing Cratis.Screenplay.Tool .NET tool package. (#203)
Screenplay (Release v4.15.0): Navigate large, hierarchical models with scoped declaration searches, dependency views, fixture queries, and revision-safe pagination. (#203)
Screenplay (Release v4.15.0): Preserve model identities across server restarts and explicitly recover interrupted source writes using root-local identity state and recovery journals. (#203)
Screenplay (Release v4.15.0): Choose single-file, module, feature, or slice layouts, with whole-model validation before changes are applied. (#203)
Screenplay (Release v4.15.0): Use typed syntax schemas and source-authoring APIs independently of executable backend readiness, with safe reference validation and verified trivia-preserving renames. (#203)
AI (Release v2.31.0): Add dedicated skills for release notes and migration guidance, verified technical examples, and LLM-friendly documentation delivery.
AI (Release v2.31.0): Make the writing skills available through documentation, content, and engineering profiles appropriate to their tasks.
Arc (Release v22.19.0): SortDirectionIsNotRecognized, the validation failure raised for an unrecognized sort direction (#2715)
AI (Release v2.30.0): cratis-social-feed-post skill covering the feed truncation model, what the opening has to do to survive it, and the formatting and reach constraints that apply to a plain-text feed.
AI (Release v2.30.0): cratis-writing-voice-and-cadence skill covering the sentence constructions and the structural sameness that make written material read as machine-generated, and the claim-preservation checks a voice pass must pass before it is accepted.
AI (Release v2.30.0): cratis/content profile composing both skills.
AI (Release v2.30.0): Executable verification scenarios for both skills.
Chronicle (Release v19.3.0): Cratis:Chronicle:Clustering:ResponseTimeout sets how long a grain call waits for its response. Some startup work grows with the deployment — the projections for an event store are registered across every namespace it has — while Orleans’ 30 second default does not, and a server that grows past that point cannot finish starting. Because it cannot finish starting it cannot start on the next attempt either, so it stays down with no way to give it more room. Defaults to the same 30 seconds Orleans uses. (#4088)
AI (Release v2.29.0): Providers.UsageReporting - ICanReportAIUsage, AnthropicUsageReporting/OpenAIUsageReporting (Anthropic/OpenAI organization usage and cost report readers), the IAIUsageReporting/AIUsageReporting orchestrator, and a live AIProviderUsageReport query for a configured provider’s trailing-30-day vendor-reported token usage and cost.
AI (Release v2.29.0): Providers.UsageReporting.SettingCredential - SetAIProviderUsageCredential/ClearAIProviderUsageCredential for the separate Admin API key a vendor’s usage report is read through.
Arc (Release v22.18.0): HttpRequestContextEndpointExtensions on Cratis.Arc.Http: SetEndpointMetadata, GetEndpointMetadata, and AllowsAnonymous() on IHttpRequestContext, so an IAuthenticationHandler can tell whether the endpoint it is about to authenticate allows anonymous access (#2706)
Arc (Release v22.17.0): IHaveKnownChanges lets an observable collection query state which of its items changed, so the delta for an emission is the one the provider already knows rather than one rediscovered by comparison. An emitted collection is still an IEnumerable<T> of the read model, so existing subscribers are unaffected, and a provider that cannot know what changed continues to be served by the comparison fallback.
Scene (Release v3.6.0): Add query input forms that submit exact string or Guid arguments to an optional-single query, with visible validation, loading, result, and not-found states. (#39)
Scene (Release v3.6.0): Add identity-aware query registration that detects ambiguous bindings while remaining compatible with existing query views. (#39)
cli (Release v3.10.0): Add --warnings-as-errors so Screenplay validation can reject compiler warnings in CI. (#168)
Components (Release v4.12.0): icons on CratisComponentsProvider, replacing Components-owned glyphs product-wide and resolved per site as per-component prop → provider icon → built-in glyph (#299)
Components (Release v4.12.0): First cut of the icon vocabulary: close, remove, expand, sortAscending, sortDescending, previous, next and clear (#299)
Components (Release v4.12.0): useCratisIcon() and CratisIconResolver, the resolver Components uses at every icon site, exported from the setup-only root barrel for product components that want to follow the same vocabulary (#299)
Components (Release v4.12.0): Chip, DataTableCore’s sort indicators, ComboBox, Dropdown, TablePaginator, DatePickerInput, ProgressSpinner, a toast’s dismiss and loading marks, CommandForm’s chips field, ChatSidebar, the Chat panel and PivotViewer’s filter/detail panels now resolve their glyphs through that vocabulary instead of hard-coding them (#299)
Components (Release v4.12.0): Documentation/Common/cratis-components-provider.md documents icons the way messages is documented: the whole vocabulary with what each name draws, its default, and every component that uses it (#299)
Components (Release v4.11.0): Per-area CSS entry points for every JavaScript subpath — @cratis/components/Dialogs/styles, @cratis/components/PivotViewer/styles, @cratis/components/DataTables/styles and the rest — so an application downloads only the CSS for the surfaces it mounts (#301)
Components (Release v4.11.0): @cratis/components/styles/base, the shared internal utilities and cascade-layer order that every per-area entry point needs, imported once and never duplicated per surface (#301)
Components (Release v4.11.0): Documentation/Styling/per-area-stylesheets.md documentation covering when to prefer them over the aggregate, the full list of entry points and what each one covers (#301)
Components (Release v4.11.0): Per-area CSS budgets in the published-archive gate: each entry point has its own reviewed gzip ceiling, and a new area cannot ship without a measured number (#301)
Components (Release v4.10.0): removeIcon on TagGroup replaces the glyph inside each tag’s remove button, defaulting to the multiplication sign it renders today. The button, its accessible name from removeLabel, and its keyboard behaviour are unchanged. (#293)
cli (Release v3.21.0): The CLI now bundles Screenplay 4.43.0 and Stage 4.20.0, and cratis run defaults to the matching Stage image. Model authors get Screenplay’s fixes up to 4.43, including given … for and when append … for in view slices, which previously failed with PLAY0273 (#193).
cli (Release v3.21.0): Chronicle login tokens only go to the server that issued them.cratis chronicle login saves the token, its expiry and the issuing server in the active context. Later commands send the token only when they connect to that exact server. If you log in with --server, the token is used when you pass the same --server again, and nowhere else. Login refuses multi-host and chronicle+srv:// connection strings, because the server that receives the token can’t be determined in advance. It also no longer follows redirects, and it honours the connection string’s TLS options instead of accepting any certificate.
cli (Release v3.21.0): All startup hints share one wait. The CLI, Stage image and Cratis AI hints get at most about 300 ms together after the command finishes, instead of up to 300 ms each. CRATIS_NO_UPDATE_CHECK now also skips the Stage image check’s local Docker lookup.
Arc (Release v22.31.0): Policies without the opt-in behave as before and still require an authenticated caller. Role requirements and authentication-scheme requirements always require an authenticated caller, even when combined with an opted-in policy. If several policies apply, a guest is only evaluated when every one of them opted in. (#2761)
Arc (Release v22.31.0): Arc’s method-level authorization replaces the type-level declaration. A method with an opted-in policy is therefore reachable by guests even when its type requires a role. The authorization docs now call this out. (#2761)
Stage (Release v4.21.0): Bundle the pinned .NET reference assemblies used for audited body binding, expose the Roslyn runtime dependency, and verify a standalone packed consumer in CI. Existing projection and body-less reducer refusal remains unchanged.
Stage (Release v4.21.0): Whole-solution Debug specs pass in serial execution (dotnet test --configuration Debug -m:1); one optional Mongo-backed test is skipped without a configured connection. Parallel local runs suffered external SIGTERM of testhost from another worktree command; isolated Rendering.Cratis 1,751 pass + 1 skip.
Stage (Release v4.21.0): Release build zero warnings, NuGet pack and standalone consumer, frontend test/build and Python compatibility/entrypoint checks pass. Full cross-provider review on the exact committed diff passed with no findings.
Chronicle (Release v19.14.1): The kernel’s observers now use the generic state machine from Cratis.Orleans.StateMachines (Cratis.Orleans 1.11.0), and Chronicle’s own copy is removed. Runtime behavior and persisted observer state are unchanged. The transition trace log category is now StateMachine<ObserverState> (#4289)
Chronicle (Release v19.14.1): Chronicle now builds against Cratis.Orleans 1.11.0, Arc 22.30.0 and Fundamentals 7.19.6 — the minimum versions Cratis.Orleans 1.11.0 requires. The Arc proxy-generator build package stays at 22.23.0 because 22.30.0 crashes on Core
Arc.TypeScript (v0.43.0): The development dependency on @cratis/chronicle is 6.19.0, and the samples use the same version. The peer range stays ^6.7.0.
Arc.TypeScript (v0.43.0): With an older SDK, a projection-backed lookup fails with an error naming @cratis/chronicle >= 6.19.0. When a declarative projection without an explicit read-model type is registered, seeded lookups of read models that have no reducer or explicit projection now fail the same way instead of returning null, because Arc cannot tell which read model that projection targets. Give the projection an explicit read-model type (@projection('', ReadModel)) or upgrade the SDK.
Arc.TypeScript (v0.42.0): The documentation recommends the co-located layout; a separate output folder remains supported, including a dedicated folder nested inside the artifacts folder, which keeps its barrels.
Arc.TypeScript (v0.42.0): A bundler that reads slice files outside the web project must lower the proxies’ decorators itself, because the web project’s tsconfig.json does not apply to them. For Vite 8, set oxc: { decorator: { legacy: true } }; declare the client packages where the slice folder can resolve them. See Set up proxy generation.
Chronicle (Release v19.13.2): Document that a webhook’s non-2xx response fails delivery: transient failures are first retried by the HTTP client, then the partition follows the observer retry settings and is quarantined when attempts are exhausted.
Chronicle (Release v19.13.2): Document that an event source can re-claim its own unique value, and that changing the value frees the old one.
Arc (Release v22.30.1): Update the Chronicle integration to Cratis.Chronicle 19.13.0, with the Cratis.Fundamentals, Cratis.Metrics and MongoDB driver versions it requires.
Screenplay (Release v4.43.0): Document that C# code bodies use provider-generated PascalCase member names, while authored Screenplay identifiers remain unchanged. The portable default tenant remains the zero GUID; provider-side tenant translation is still pending. Refs #282.
Screenplay (Release v4.43.0): Decision records 0012 and 0018 now use the supported implemented stage and retain their outstanding provider-verification notes.
Screenplay (Release v4.42.0): A projection block that repeats automap or no automap reports PLAY0452 (warning). The last setting still wins, and canonical printing keeps each line’s comments.
Chronicle.TypeScript (Release v6.20.0): Reject constraints, batch appends (appendMany and plural when.events), and other unproven operations or inputs with UnsupportedEventSequenceOperation, which points to a kernel-backed test. Constraints can be disabled explicitly only for tests that do not depend on them.
Arc.TypeScript (v0.41.0): In PostgreSQL mode, notifyChanged() validates its target but publishes nothing locally; the database trigger is the only change source. In-process mode is unchanged.
Components (Release v4.16.0): Tooltipcontent accepts any React node, and 0 now shows. undefined, null, booleans, and an empty string still disable the tooltip. Keep tooltip content non-interactive. Renderer adapters that implement common.tooltip receive nodes and must render them as they are; the Conformance profile now checks this. (#230)
Components (Release v4.16.0): FilterPanel is now a named, non-modal dialog. Opening it moves focus into the panel, and Escape closes it and returns focus to the element that opened it. It now renders as a div with role="dialog" instead of an <aside>, so it is no longer a complementary landmark: getByRole('complementary') no longer finds it, and CSS or tests that target the aside element must use .pv-filter-dropdown or getByRole('dialog', { name }) instead. This also applies to the filter panel inside PivotViewer. (#328)
Components (Release v4.16.0): Loading and failure rows in query tables now remount on each state change, so screen readers announce the change. (#327)
Components (Release v4.16.0): Conformance merges a part variant’s own pt attributes with the profile’s pass-throu
Chronicle (Release v19.12.0): Pattern mining derives request features from route templates only, never from raw request paths, so identifiers embedded in a URL (such as /customers/jane@example.com) are no longer stored in mined patterns. Patterns stored before this release are not rewritten (#4260)
Chronicle (Release v19.12.0): Registering an event type whose stored schema differs only in titles no longer rewrites the stored schema, and no longer invalidates caches on every reconnect. This matters when old and new clients run side by side (#4253)
Chronicle.TypeScript (Release v6.19.0): Reducer replay in ReadModelScenario moved behind an internal read-model processor. Reducer behavior is unchanged.
Arc.TypeScript (v0.40.0): A service scope captures an immutable snapshot of its execution context when it is created. ServiceScope.identity returns that snapshot, and the Chronicle, MongoDB and Drizzle integrations use it, so changing the original context object after a scope was created no longer changes the tenant those services use. Principals whose claims can’t be cloned keep working for ordinary requests.
Chronicle (Release v19.11.0): A reactor whose return value no side-effect handler claims now fails its partition, naming the return type, instead of logging a warning and acknowledging the event. Fix the handler, then retry the partition (#4156)
Chronicle (Release v19.11.0): Duplicate reactor IDs, across discovered classes and runtime delegates, are rejected before existing subscriptions disconnect, and the error names both types. A duplicate Register<T>() now throws ReactorAlreadyRegistered instead of ArgumentException (#4196)
Chronicle (Release v19.11.0): A WaitForCompletion() timeout returns a result with TimedOut set instead of throwing a gRPC cancellation. Supported servers also report which observers are still behind (#4132)
Chronicle (Release v19.11.0): Read-model instance pages from MongoDB, SQL and in-memory sinks are ordered by key, so reading a page again returns the same instances while membership is unchanged (#3741)
Chronicle (Release v19.11.0): A dynamic dictionary key that uses an unknown $ expression fails with UnsupportedDynamicPropertyPathExpression instead of being written as a literal key (#4119)
Chronicle (Release v19.11.0): SQL redaction content describes the original event (type, occurrence time, correlation id, caused-by identities and causation types) instead of the redaction itself, matching the other providers (#4145)
Chronicle (Release v19.11.0): Cratis.Chronicle.Testing depends on Cratis.Arc and Cratis.Arc.Core 22.19.1 or later, which brings in the ASP.NET Core shared framework. Projects pinned to an older Arc must upgrade (#4158)
Chronicle (Release v19.11.0): Aspire uses the development Chronicle image in run mode and the production image in publish mode. A configuration callback no longer implies the production image; WithImageTag still overrides (#3686)
Chronicle.TypeScript (Release v6.18.0): Model-bound children now fill their identifier the way Chronicle for .NET does. When the child’s identifier is a discoverable id/Id or given with identifiedBy, and the child key defaults to the event source ID, the identifier comes from the event source ID. When no id exists and a child property matches an explicit event key, that property becomes the child’s identifier. Explicit identifier mappings and class-level @noAutoMap still take precedence.
Arc (Release v22.28.1): Query argument parsing is stricter: values that previously fell back silently now return HTTP 400, including ?flag=1 or ?flag=yes for a boolean, overflowing integers, whitespace-only values, invalid nullable value types that used to become null, and invalid concept values (including nullable or defaulted concepts). Clients must send valid values or omit optional arguments.
Arc (Release v22.28.1): The new public InvalidQueryArgument exception represents an invalid supplied query argument; QueryHttpExtensions.GetQueryArguments can now throw it. Invalid collection elements use the same named malformed-request validation shape.
Arc (Release v22.27.1): Creating several Arc Core containers over the same types is faster: model-bound command, query and read-model discovery runs once per type set and is reused. A local .NET 10 Release measurement of 50 containers over 581 types dropped from 58.8 ms to 23.7 ms median, about 60% faster (#2673)
Arc (Release v22.27.1): Read models no longer expose private static methods or compiler-generated methods as queries through runtime discovery; public and internal static query methods remain supported (#2651)
Chronicle (Release v19.10.0): all inside children or nested. Use all at the root with a dotted path instead.
Chronicle (Release v19.10.0): remove via join at the root or inside nested.
Chronicle (Release v19.10.0): join inside a nested object beneath children.
Chronicle (Release v19.10.0): More than one every/all block at the same level. Two every blocks inside children used to be merged; they are now an error.
Chronicle (Release v19.10.0): The same event more than once at one level, including across join blocks, repeated clear with, and remove with plus clear with for the same event. These checks now also run when no schema is supplied.
Stage (Release v4.20.0): Stage targets Chronicle 19.8.1, Arc 22.25.0 and Screenplay 4.41.1. Generated applications and the Host image use the same versions, and CI checks the Chronicle projection oracle against v19.8.1.
Stage (Release v4.20.0): The semantic engine no longer registers Chronicle projection mirrors, so its read models no longer appear as projection views in the Workbench. The admission endpoint no longer reports projectionMirror. The default engine is unchanged.
Stage (Release v4.20.0): Specifications that assert a value derived from $context.occurred are rejected, because the generated handler uses the actual time.
Chronicle.TypeScript (Release v6.16.0): Reactor handlers are always called with the third services argument. One- and two-argument handlers are unaffected; a handler that collects arguments with a rest parameter now receives one more.
Chronicle.TypeScript (Release v6.16.0): Without an activator, reactors and reducers are still constructed once per observation with no arguments, exactly as before.
Chronicle.TypeScript (Release v6.16.0): The reactor documentation covers explicit appends, read-model lookups, activation lifetimes, and replay: @onceOnly() keeps a handler out of replay but does not protect against retries or duplicate delivery, so explicit writes should be idempotent. The four TypeScript snippets for explicit appends and reading state inside a reactor now show working code.
Arc.TypeScript (v0.39.0): The proxy generator analyzes every execution path of a command’s return type, including Outcome helpers, promises, aliases and nested tuples, and accepts alternatives that resolve to the same client type. Literal unions such as boolean, enums and 'a' | 'b', with or without null/undefined, keep their full type, distinct concepts fall back to their shared primitive, and arrays that mix Chronicle event types are omitted from the client response as before.
Arc.TypeScript (v0.39.0): Alternatives that need different client types, including two structurally identical but distinct DTO classes, now fail generation with guidance to return one response DTO with a status field. Arc for .NET’s generator picks one of them instead, which the client can’t decode reliably.
Arc.TypeScript (v0.39.0): Generated metadata for queries returning boolean, enums or literal unions now names the element type, so OpenAPI describes their data.
Arc.TypeScript (v0.39.0): The command outcomes guide describes how to model several business outcomes.
AI (Release v7.1.0): Package unmodified Laya at commit 4066d5d5 with a CPU-only Decision API v1 adapter and pinned multilingual checkpoint.
AI (Release v7.1.0): Preserve built-in v1 single/batch contract, add independent multi-label /v1/labels and typed ClassifyLabels() for callers.
AI (Release v7.1.0): Test the packaged image in release CI and publish the Laya candidate image tag.
AI (Release v7.1.0): Image build and five adapter tests passed; five C# classification specs passed; AI and Infrastructure builds passed.
AI (Release v7.1.0): 10-issue workload against the packaged image: 30 sequential in 4.12s, batch in 3.97s, label requests in 6.96s.
Chronicle (Release v19.9.0): An append with no events but at least one concurrency scope that will actually be checked is now accepted and only validates those scopes, so a command that decides to write nothing can still confirm its decision was current. Empty appends without such a scope are still rejected, and empty appends no longer notify append subscribers.
Chronicle (Release v19.9.0): Requires Chronicle kernel 19.0.0 or later for decision reads. With plain ASP.NET Core the middleware commits after the response is written, so a caller that needs a conflict-aware response must commit before writing it.
Arc.TypeScript (v0.38.0): rxjs is now a required peer dependency of @cratis/arc.drizzle.
Arc.TypeScript (v0.37.0): A query declared as a snapshot that returns an observable, subscribable or async iterable is rejected without touching the returned source, so a shared RxJS Subject stays usable.
Arc.TypeScript (v0.37.0): QueryScenario releases such a stream before rejecting, with a one-second limit and cancellation support. Sources returned inside a scenario are treated as owned by the scenario and may be closed.
Arc.TypeScript (v0.37.0): QueryScenario.perform() now rejects queries declared observable: true, as QueryScenario does in Arc for .NET; use ObservableQueryScenario for them.
Arc.TypeScript (v0.37.0): yarn ci now type-checks the built declarations of every published package with skipLibCheck: false, so a declaration a consumer can’t compile fails the build.
Arc.TypeScript (v0.36.0): Projects that use recommended-type-checked can see new ARCCHR0006 diagnostics on reactors that return commands without @onceOnly() or @replay().
Arc.TypeScript (v0.36.0): The code-analysis navigation lists the ARCCHR0003, ARCCHR0006, ARCCHR0007, ARCCHR0009, and ARCCHR0010 pages.
Chronicle.TypeScript (Release v6.14.1): When a property-only model can’t be found at store creation (for example, an import-only model in compiled JavaScript without discovery patterns), the client logs one diagnostic warning per process, naming the mapped properties and their event types. It suggests adding a class-level @fromEvent(...), enabling artifact discovery, or registering the class explicitly. Mappings inherited from base classes or reachable through child types don’t trigger the warning.
Chronicle.TypeScript (Release v6.14.1): The getting-started, read-model and troubleshooting guides describe these registration options.
Arc (Release v22.26.0): Plain minimal API responses that return concepts change from objects such as {"value":"..."} to primitive values such as "...", matching Arc-generated endpoints and the TypeScript proxies. To keep the object shape for a concept, register your own JsonConverter<YourConcept> with ConfigureHttpJsonOptions; it takes precedence for individual concepts, concept collections, and, when it implements property-name conversion, dictionary keys, whether registered before or after AddCratisArc (#2755)
Arc (Release v22.26.0): Only concept-related converters are added to ASP.NET Core’s HTTP JSON options. Your converters keep precedence and the naming policy is unchanged; enums (including long-backed va
Arc.TypeScript (v0.35.0): Paging and sorting parameters are listed only for queries whose return is declared as an array or a queryPage result. A metadata-free array query no longer lists them; to list them again, set generatedReturn: { cardinality: 'many', nullable: false } on its descriptor. Queries that rely on a QueryRenderer to page are not advertised as pageable.
Arc.TypeScript (v0.35.0): 401 responses are listed on command execute, command validation, and query operations exactly when authentication can produce them.
Arc.TypeScript (v0.35.0): page and pageSize are described as int32, and the paging parameter descriptions match Arc for .NET.
Arc (Release v22.25.0): For a command that declares a blocking severity, the caller’s X-Allowed-Severity (or allowedSeverity) can make validation stricter, never looser. A failure with Unknown severity also rejects such a command. Commands without the attribute behave as before. This deliberately differs from the caller opt-out for controller actions in #21; decision 0005 records why.
Arc.TypeScript (v0.34.0): ValidationResult is now both the existing interface and a value holding the helpers. Existing import type { ValidationResult } imports and the validation(message, members?, reason?, severity?) helper are unchanged.
Chronicle (Release v19.8.1): Generating a declaration from a stored, untyped composite-key expression takes the key type from the read model’s Id schema (including nullable types), or from the child item’s Id inside a children block. When the schema has no composite type it falls back to CompositeKey, and in that case the generated declaration only recompiles if the schema defines that type.
Components (Release v4.15.1): yarn ci in Source now also runs the public API TSDoc check and the packed-archive CSS budget check, which previously ran only in GitHub CI.
Stage (Release v4.19.0): Stage now uses Screenplay 4.41.0. Models with evolved events (ESM v4) are still refused with STAGE-ESM-016, which is now reported before any descriptor check.
Stage (Release v4.19.0): The reducer-body rejection (STAGE-ESM-019) names only what is still missing.
Stage (Release v4.19.0): Specifications attach typed event-source context for every executable-model version after v1, as Screenplay’s reference evaluator does.
Arc.TypeScript (v0.33.0): givenReadModel(Type, sourceId, instance) without a tenant now pins the model for the scenario’s current context.tenantId, not always Default. It still falls back to Default when the context sets no tenant.
Arc.TypeScript (v0.33.0): A read model with no seeded history and no pin resolves as missing. A required model reports the usual not-found validation result, and an optional one receives null.
Arc.TypeScript (v0.33.0): A projection-backed read model with seeded history, and aggregates, point to ChronicleKernelScenario. Projections need the kernel.
Components (Release v4.15.0): While a query table’s first result loads, or when its query fails or is unauthorized, the table now renders the new loading or failure row instead of an empty empty-row/emptyMessage. empty-row still renders for a query that returns no rows. If your CSS or tests target empty-row to detect loading or errors, update them to the new parts. (#327)
Components (Release v4.15.0): An observable query that is missing a required argument never subscribes, so its table now shows the loading row until every required argument has a value; before, it showed a blank row. A snapshot query missing a required argument still shows emptyMessage. (#327)
Components (Release v4.15.0): ToolbarButton exposes aria-pressed when you pass active, so assistive technology announces the toggle state. Buttons without active are unchanged. (#328)
Components (Release v4.14.3): release.md documents the release order and every place the Components major-version window is set.
Arc.TypeScript (Arc for TypeScript 0.31.0 — global command and query filters): Cancellation stops every stage that has not started: authorization policies, filters, validators, dependency resolution, provide(), handle(), query performers, renderers, read-model interceptors, observable producers, and command response handlers. Once a command handler has run, the command reports what actually happened. A completed outcome is not turned into a cancellation failure. A response handler that cancellation stops before it starts is reported as canceled. An effect that was already acknowledged is never reported as undone.
Arc.TypeScript (Arc for TypeScript 0.31.0 — global command and query filters): A defined Chronicle command whose append was acknowledged keeps its success when cancellation stops the wait for projections. A real observer failure is still reported.
Arc.TypeScript (Arc for TypeScript 0.31.0 — global command and query filters): Each filter result’s validation entries are filtered by the allowed severity before the chain decides whether to stop. A filtered-out warning therefore cannot switch off later authorization filters. This deliberately differs from Arc on .NET, which stops before severity filtering.
Chronicle.TypeScript (Release v6.14.0): Reducer handler selection and invocation are shared by the production observer and the scenario. Production behavior is unchanged.
Chronicle.Elixir (Release v3.6.0): cratis_chronicle_contracts bumped from 19.4.7 to 19.6.1, the first release carrying the RemoveObserver rpc
Chronicle.TypeScript (Release v6.13.0): @cratis/chronicle.contracts bumped from 19.4.0 to 19.6.1, the first release carrying the RemoveObserver rpc
Chronicle.Kotlin (Release v6.6.0): chronicle-contracts bumped from 19.5.0 to 19.6.1, the first release carrying the RemoveObserver rpc
Chronicle (Release v19.7.2): Fluent .FromAll() and model-bound [FromAll] projections now subscribe to every event type in the event sequence, as a declaration all block already does. Existing projections that use FromAll will be redefined, and will start creating or updating read-model instances for events from any event source, keyed by event source id unless another key is given. Use FromEvery for mappings that should only apply to the projection’s own event types. Combining FromAll with FromEvery applies both sets of mappings to all event types. Event types already mapped through From, a join or a derivative are not processed a second time by the all-events subscription (#4164)
Screenplay (Release v4.40.0): Specification given events now go through the same establishment path. Existing specification outcomes are unchanged.
Screenplay (Release v4.39.0): A valid persona no longer stops a model from binding to the executable model. It is reported as information only, and models that already bound produce the same bytes. Personas and providers are still not part of the executable model; the authentication documentation describes where a renderer reads provider identities from the compilation result. This is part of #254.
Screenplay (Release v4.39.0): A persona whose policy cannot be resolved is now an error in compilation, Safe authoring and executable binding, so it never falls back to anonymous access. Draft authoring still accepts it and reports the unresolved reference.
Screenplay (Release v4.38.0): PLAY0284 follows what Chronicle fills in a join. It counts a join’s mapped fields and compatible AutoMap fields instead of the join’s label, which Chronicle discards. It no longer counts a field that AutoMap cannot fill because an explicit mapping already uses the same event field. It also no longer counts fields that only a join inside a nested block would fill, because Chronicle does not currently apply joins there. Models that relied on those cases now get PLAY0284 for fields that stay empty at runtime. (#262)
cli (Release v3.20.0): The CLI now bundles Screenplay 4.37.0 and Stage 4.18.1, and cratis run defaults to the matching Stage image.
Chronicle.TypeScript (Release v6.12.0): Projections, reducers and readModels.register() build read-model definitions through one shared builder. Definitions for read models without @index() are unchanged.
Screenplay (Release v4.37.0): Models with multiple event generations select ESM v4. A lone generation 1 keeps its previous ESM version, and v1–v3 canonical bytes are unchanged. Consumers must explicitly admit v4 before accepting these models; generation transformations, historical replay and Chronicle deployment support remain separate work under #71.
Screenplay (Release v4.37.0): ESM v4 no longer serializes projection-transition cardinality and rejects the legacy ZeroOrOne and Many values. Query cardinality is unchanged (decision 0007; part of #132).
Screenplay (Release v4.37.0): References to removed current-generation properties fail binding instead of falling back to historical shapes. MCP understands generation-qualified addresses and exports canonical v4 models.
Arc.TypeScript (Arc for TypeScript 0.30.4 — tested with Chronicle SDK 6.10): Mark the live command-returning reactor @onceOnly() and document the replayable-by-default behavior introduced in SDK 6.9.0. Failed-partition recovery still requires repeat-safe effects.
Arc.TypeScript (Arc for TypeScript 0.30.4 — tested with Chronicle SDK 6.10): Document subscription-marker filtering, compiled-JavaScript artifact discovery, and credential-rejection behavior. Correct the package README to describe its bounded live-kernel coverage.
Chronicle.TypeScript (Release v6.11.0): getInstanceById is no longer deprecated. It is the canonical read-by-key API, as GetInstanceById is in .NET, and its behavior for a missing instance is documented. findInstanceById remains for code that wants null when no instance exists.
Chronicle.TypeScript (Release v6.10.0): Artifact discovery no longer scans .ts sources when your program runs as compiled JavaScript. Artifacts register when their modules are imported. When the program runs from TypeScript (a .ts, .tsx, .mts, or .cts entry file, Vitest, or a tsx, ts-node, or type-stripping loader), the default still scans **/*.ts, and now also **/*.tsx. An explicit discoveryPatterns is always used as given.
Chronicle.TypeScript (Release v6.10.0): glob is now a dependency of @cratis/chronicle, and ! patterns in discoveryPatterns exclude files as documented. When a discovered file fails to import, the error names the file.
Chronicle.TypeScript (Release v6.10.0): A failed token request no longer stops the call. The client logs the token endpoint and cause, then sends the call without a token, the same way the .NET client does. A kernel with authentication turned off is therefore reachable, and an unauthenticated rejection reports the token failure. When the kernel rejects a cached token, the client refreshes it and retries the call once.
Chronicle.TypeScript (Release v6.10.0): With client credentials, tokens are requested from the server the client selected for the connection, not always from the first host in the connection string.
Chronicle.TypeScript (Release v6.10.0): A declarative join without .on(...) now fails when the projection is built, with a clear message. A join inside .children(...) uses the children’s identifiedBy as its default, whatever the call order.
Chronicle.TypeScript (Release v6.10.0): The keep-alive reports the installed client version instead of 1.0.0.
Chronicle.Kotlin (Release v6.5.0): A read model marked @Passive is registered without a sink and computed from its events on read, so a read right after an append includes that event. Data a previous version stored for such a model is no longer read.
Chronicle.Kotlin (Release v6.5.0): registerAll() throws ArtifactRegistrationFailed when a reactor or reducer cannot be started. It still starts the others, captures and seeders first. The automatic pass on connect logs each failure and retries the failed observers on the next reconnect.
Chronicle.Kotlin (Release v6.5.0): In Spring Boot, a kernel that rejects the connection at startup now stops the application with ChronicleConnectionFailed. It no longer starts and leaves every appending request waiting.
Chronicle.Kotlin (Release v6.5.0): A connection string with apiKey is rejected at client creation with IllegalArgumentException. The kernel has no API key authentication, and such a client used to connect with no credentials at all.
Chronicle.Kotlin (Release v6.5.0): Seed entries without forNamespace() are sent as global seed
AI (Release v7.0.0): DecisionResult.Provider is replaced by DecisionResult.Engine, a DecisionEngineType, and the decision.engine telemetry tag replaces the provider tag
Stage (Release v4.18.0): Stage now uses Screenplay 4.35.0 and its canonical corpus.
Stage (Release v4.18.0): Reaction trigger reads (Screenplay 4.31) is accepted and adds no runtime behaviour, since Screenplay binds no runtime meaning to it yet. Stage’s documentation says so, and that matching children in a child join is left to Chronicle.
Chronicle.TypeScript (Release v6.9.0): Reactors are now replayable by default, as in .NET. Existing reactors accept explicit replays. They also accept kernel-initiated replays, such as rewinds after an event revision or redaction, and replays after a definition change when that option is enabled. Before upgrading, mark reactors that cause side effects with class-level @onceOnly(), or mark individual handlers when only those handlers must be skipped.
Chronicle.TypeScript (Release v6.9.0): Reactor registration fails for a @replay() handler that matches no registered event type, and for two replay handlers for the same event type.
Chronicle.TypeScript (Release v6.9.0): Inherited replay handlers are found, and the most derived method wins.
Arc (Release v22.23.2): During a scenario, code that reads Arc’s process-wide provider directly, such as the MongoDB and EF Core Observe() extensions, now sees the host’s provider, or throws ServiceProviderNotConfigured when no host has set one, instead of using the scenario’s provider. Command validation in a scenario is unaffected (#2763)
Chronicle (Release v19.7.0): The job system is now Cratis.Orleans rather than Chronicle’s own. The local engine, its storage for MongoDB and SQL, and its specs are gone; what remains here are the job scenarios that are about Chronicle
Chronicle (Release v19.7.0): Job storage is resolved through IJobsStorage. The kernel asked for the concrete MongoDB type, which the container satisfied by building a second, unconfigured instance - grains wrote to one database and the kernel read from another, and reading an always-empty database does not throw. Six integration specs asserted job steps were empty and passed for the wrong reason
Chronicle (Release v19.7.0): The kernel names its own assemblies for BSON serializer registration. Adopting the package’s registration silently dropped every serializer the kernel ships, including the one that upgrades constraint definitions written before 16.12
Chronicle (Release v19.7.0): A development wipe tells the job system its database was emptied, so the tables it creates on resolution are made again
Chronicle (Release v19.7.0): A replay specification no longer depends on catching a transient job. A replay job is removed the moment it completes, and two events against a fast database finish before the first poll looks; the replay is verified from the rebuilt read model and the absence of a recommendation instead
Templates (Release v1.7.1): The README.md generated into every project lists the prerequisites the templates really need: the .NET 10 SDK (every .NET template targets net10.0), JDK 17 for the Kotlin and Java templates, Docker with the Compose plugin, and Node.js ^20.19.0 or >=22.12.0
Templates (Release v1.7.1): The post-creation instructions and generated READMEs use docker compose instead of the standalone docker-compose command
Templates (Release v1.7.1): The generated READMEs now show expected output, the Chronicle health check, how to stop without losing data, and a warning that the development containers publish their ports on every network interface with well-known credentials
Templates (Release v1.7.1): The Kotlin and Java READMEs explain that the Cratis Gradle plugin and dependency float on latest.release, how Gradle caches that, and how to pin versions for reproducible builds
Templates (Release v1.7.1): The template documentation’s getting-started page is now a step-by-step tutorial that ends with a registered item. Each template page lists its options, how to run it, and troubleshooting
Chronicle.TypeScript (Release v6.8.0): Same-named fluent uniqueFor declarations across classes, together with decorated event types of the same name, are merged into one definition. Before, each registered its own definition with the same name.
Chronicle.TypeScript (Release v6.8.0): hasFor looks constraints up by their registered name, as HasFor does in .NET.
Chronicle.TypeScript (Release v6.8.0): A message configured with withMessage now replaces the kernel’s message in append results.
AI (Release v6.4.0): Keeping an external link out of a LinkedIn post’s body is an editorial default with a reader-need exception, not a claimed ranking penalty. The feed skill no longer says that expanding a post is a ranking signal, or that pseudo-formatting defeats search.
AI (Release v6.4.0): Hacker News: AI doesn’t write or edit anything Cratis posts there.
Screenplay (Release v4.34.0): Two unmarked declarations of the same event in one slice are now a syntax error (PLAY0447, a duplicate generation 1); before, only binding rejected them.
Screenplay (Release v4.34.0): References to an event and the checks on its shape (produced mappings, specifications, projections, reaction trigger values) use the current, highest generation.
Screenplay (Release v4.34.0): Tools that read EventSyntax directly will now see one declaration per generation. Until the executable model carries lineage, they should reject or skip events that carry a generation marker (HasGenerationMarker).
cli (Release v3.19.0): Chronicle bumped from 18.1.0 to 19.6.1 to pick up RemoveObserver and the RetryPartitionResponse outcome
cli (Release v3.18.0): cratis render passes the model’s implementation requirements and resolved code to Stage, so a missing or changed body stops rendering with STAGE-ESM-020 and the loader’s reason. (#184)
cli (Release v3.18.0): The CLI now bundles Screenplay 4.32.0 and Stage 4.17.0, and cratis run defaults to the matching cratis/stage:4.17.0 image.
cli (Release v3.18.0): The render and run reference recommends a dedicated folder for models with file attachments: a single-file cratis run mounts only the .play file.
Screenplay (Release v4.33.0): A join inside children now matches children by their identity, as Chronicle does, instead of by the join’s on property. Specifications where they differ may produce different results.
Stage (Release v4.17.0): Code validation, reducers with bodies and code policies are still rejected, and their diagnostics now name only what is still missing: Arc does not supply the received-at time for RuleContext.Occurred or PolicyContext.Occurred, Stage does not yet enforce the pure capability, and reducers wait for Screenplay’s typed context descriptor.
Stage (Release v4.17.0): The renderer guide describes the attachment envelope, what planning verifies, and that a single-file model’s root is its folder.
Orleans (Release v1.10.0): A job completes CompletedWithFailures when any step is unreachable, not only when a step failed. JobProgress.IsCompleted and IsStopped count unreachable steps. (#27)
Orleans (Release v1.10.0): Start returns once the first stage is running for a job with stages. Its start errors describe that stage, and later stages report their start failures through the job. (#27)
Chronicle.TypeScript (Release v6.7.1): The README, documentation, JSDoc and console samples now use inferred read models instead of the deprecated @readModel decorator. Existing applications need no changes, and @readModel is still supported.
Arc.TypeScript (Arc for TypeScript 0.27.0 — Drizzle read models in commands): Only read models whose table declares exactly one column with .primaryKey() and a model @field on it can be injected into commands. Other read models still serve queries. A command that injects one of them fails when the application is built.
AI (Release v6.3.0): The Screenplay skills now describe Screenplay 4.31.0. Every example in them compiles with that version with zero diagnostics, and both complete examples pass the reference runner.
AI (Release v6.3.0): Reaction triggers can declare the views an automation decides from: reads <View> [as <alias>] [by <trigger value>]. The skills cover:
AI (Release v6.3.0): the alias rules, which are the same as for commands (PLAY0410–PLAY0412);
AI (Release v6.3.0): by naming a trigger value (PLAY0442);
AI (Release v6.3.0): clock triggers reading whole views only (PLAY0443);
AI (Release v6.3.0): the @reads escape (PLAY0175, PLAY0444);
AI (Release v6.3.0): trigger reads, like command reads, giving no runtime protection yet.
AI (Release v6.3.0): Model authoring explains how the ESM version (v1, v2 or v3) follows from what a model uses. It separates four states: parsed, bound, reference-executed and target-executed. A table checked against the binder lists what binds, what binds only as opaque code, what binds but the reference execution plan refuses, and what blocks binding.
AI (Release v6.3.0): Model authoring covers code attachments (loading, content hashes, source maps) and describes how comments are kept and reviewed.
AI (Release v6.3.0): Command guidance covers read aliases, validation severity, the matches email pattern, authorization order, one require per policy, what produces can bind, and unique constraints with their lifecycle forms.
AI (Release v6.3.0): Projection guidance follows how Chronicle interprets projections: an unkeyed from routes by event source, every runs for a level’s from and join events, and join, all and auto-map behave as Chronicle lowers them. It also covers bodied reducers as opaque code and projection variants.
AI (Release v6.3.0): Specification guidance is rewritten for given caller, then denied, when append, scenarios without a when, subset versus exactly comparisons, events in any order, and typed values. It includes one complete example whose six specifications pass the reference runner.
AI (Release v6.3.0): Query and screen guidance states what from parameters and observable guarantee, which query shapes bind, how to specify query authorization, and how UI interactions (behavior, on, uses) differ from application triggers.
AI (Release v6.3.0): Captures and reactions guidance scopes the unknown-trigger warning and describes reaction code as an attachment.
AI (Release v6.3.0): Decision 0006 is shown as shipped in 4.31.0. Decisions 0007–0014 are marked as not yet available.
Screenplay (Release v4.31.0): A trigger value named reads must now be written @reads. A bare reads line or reads <PrimitiveType> under a trigger reports a diagnostic that names the escape instead of being misread.
Screenplay (Release v4.31.0): Clock triggers (every, at) can read whole views but cannot use by, since they take no values.
Screenplay (Release v4.31.0): Neither command nor reaction reads bind at runtime yet; editor guidance says so. for each <View> stays reserved.
Stage (Release v4.16.2): A model whose authorization references an opaque (code) policy still fails with STAGE-ESM-015, and the diagnostic now names what is missing: the policy’s implementation attachment is not part of the render request, and Arc has no exact received-at time for PolicyContext.Occurred. Stage never emits a policy with a substituted time or a predicate that silently denies.
Stage (Release v4.16.2): The renderer guide documents that a keyed query’s policy subject is the query key, matching Screenplay’s reference evaluator.
Arc.TypeScript (Arc for TypeScript 0.24.0 — Core namespaces and clean builds): Builder methods added by integration packages (withChronicle, withMongoDB, withDrizzle, addCratis) are typed through a builder extension interface, so they type-check wherever the builder is used, including in @cratis/arc.testing and in installed packages.
Stage (Release v4.16.1): A model with reducer implementation bodies still fails with STAGE-ESM-019. The diagnostic now names what is missing: Screenplay’s per-transition typed context descriptor for State and Event (ContextVersion 1, ResultVersion 1), tracked in Cratis/Screenplay#139. (part of #119)
Arc.TypeScript (Arc for TypeScript 0.22.0 — grouped options): ArcServerOptions is now ArcOptions, grouped like .NET: correlationId.httpHeader, tenancy.httpHeader and tenancy.resolve, generatedApis (including enableQueryMethod and openApiVersion), hosting (maxBodyBytes, applicationUrl) and query (observable limits, allowed origins, emission guards, health and keep-alive). Configuration files and Cratis__Arc__... environment variables use the same .NET paths, and Query:KeepAliveInterval accepts hh:mm:ss.
Arc.TypeScript (Arc for TypeScript 0.22.0 — grouped options): exposeExceptionDetails controls whether HTTP results include exception details and defaults to on only in the Development environment; development now only enables development discovery of users and tenants.
Arc.TypeScript (Arc for TypeScript 0.22.0 — grouped options): builder.withChronicle(), withMongoDB(), withDrizzle() and addCratis() are declared by their own packages, so @cratis/arc.core no longer depends on knowing them.
Stage (Release v4.16.0): The semantic engine reports loading while it rebuilds, and refuses requests until it is ready. After any append by another client it stops serving requests rather than drift from the log. (part of #23)
Stage (Release v4.16.0): A rebuild is refused for event contracts with date-time or decimal properties, because Chronicle’s storage changes those values (offsets, precision). It is also refused for null optional values, non-text destinations, a causedBy name that changed over time, and duplicate tags. The bundled sandbox container resets its kernel on restart, so rebuilding applies when the host runs against an external or persistent Chronicle. (part of #23)
Stage (Release v4.15.0): Update to Screenplay 4.30.0 and Chronicle 19.4.8, including the Host’s bundled kernel image and the Chronicle client and image pinned for generated applications.
Stage (Release v4.15.0): Screenplay ESM v3 models are admitted. Their new constructs fail closed:
Stage (Release v4.15.0): reducers with implementation bodies are rejected with STAGE-ESM-019;
Stage (Release v4.15.0): code validations and rule predicates are rejected with STAGE-ESM-005;
Stage (Release v4.15.0): opaque policies are rejected with STAGE-ESM-015.
Arc.TypeScript (Arc for TypeScript 0.21.0 — vertical slices and the Library sample): @cratis/arc.chronicle requires @cratis/chronicle 6.7.0. Read models are recognized from the projections, reducers and projection decorators that build them, so an Arc @readModel() class with Chronicle projection decorators needs no second read-model decorator.
Arc.TypeScript (Arc for TypeScript 0.20.0 — Fetch runtimes): @cratis/arc.core remains the Node.js entry with discovery, configuration files, the standalone host, static files and WebSockets.
Arc.TypeScript (Arc for TypeScript 0.18.0 — RxJS observable queries): MongoDB observe() and observeById() and Chronicle read model watch() return RxJS observables. Code that iterated their previous async iterables should switch to the *Iterable() methods.
Stage (Release v4.14.0): The structural specification engine is deprecated. ISpecificationRunner, SpecificationRunner and the structural run strategies are marked [Obsolete], and SpecRunner prints a one-line notice on stderr when it runs the structural engine. The default engine and exit codes are unchanged; use --engine semantic or ISemanticSpecificationExecutor. The structural engine is removed in the next major version. (part of #15)
Stage (Release v4.14.0): The scoped projection shapes that still fail with STAGE-ESM-017 now state the verified cause. Clearing and then re-creating a nested object fails the projection on MongoDB (Cratis/Chronicle#4166). Removing a joined child across several parents diverges only in Chronicle’s testing engine (Cratis/Chronicle#4167). (part of #117)
Chronicle.TypeScript (Release v6.7.0): @readModel() is deprecated. Existing identifiers set through it keep working; new code can drop the decorator.
Chronicle.TypeScript (Release v6.7.0): Registering two read models with the same identifier fails with an error instead of letting one silently replace the other.
AI (Release v6.2.0): Providers/Configuring is documented as deliberately excluded from the flat barrel: it declares commands with the same names as those in Adding, Reconfiguring, Removing and Renaming, so exporting both is ambiguous. Import it by path.
Stage (Release v4.13.0): In the semantic engine, keyed queries are served with their modeled authorization. The compatibility Get…ById/All… queries are served only for read models whose keyed queries are unprotected. (part of #23)
Stage (Release v4.13.0): The semantic engine refuses a model it cannot compile, or a Chronicle log that is not empty, with a typed status instead of starting partially. If an append’s outcome is unknown, it stops serving requests rather than drift from the event log. (part of #23)
AI (Release v6.0.0): ConfiguredAIProvider carries the provider’s endpoint, tier mapping, usage credential, usage ceiling, rate-limit cooldown and discovered catalog. Its properties are non-nullable with sentinel defaults: a nullable property on a [Passive] read model reads back null from a running kernel however the events were recorded, while in-process scenarios populate it happily - so a value could be configured, recorded, and invisible to the code that resolves a provider, with nothing failing.
AI (Release v6.0.0): AnthropicProviderClient takes the Claude Code transport alongside its quota tracker.
AI (Release v6.0.0): ReconfigureOpenAIProvider and AddOpenAIProvider record which kind of credential arrived, and refuse a subscription record that is too incomplete to be spent.
AI (Release v6.0.0): ProviderConcurrencyGate is a singleton. It holds per-provider semaphores in instance state and was registered nowhere, so every resolution got a fresh set and the gate limited nothing.
AI (Release v6.0.0): Claude Code usage reports cached tokens separately instead of folding them into the input count - a cache read is billed differently from a fresh input token.
AI (Release v6.0.0): The three event types that carried an explicit GUID identifier now key on their type name like every other event type. No stored event anywhere used those GUIDs.
Arc.TypeScript (Arc for TypeScript 0.13.0 — observability, interceptors and derived types): Properties of @field-declared models are written in camelCase on the wire, including PascalCase and acronym-leading names, the same way Arc on .NET names them. Plain objects, dictionaries and low-level Zod results are sent as they are, and generated proxies use the same names.
AI (Release v5.0.0): A model tier that no operator mapped is now resolved from the models the provider actually published, rather than from a built-in per-vendor table of model names. A tier can no longer resolve to a model a provider does not serve.
AI (Release v5.0.0): TierModelResolution.Resolve takes the provider’s available models in place of its AIProviderType. An explicit mapping still wins, tier by tier.
Arc.TypeScript (Arc for TypeScript 0.12.0 — Chronicle event sourcing): Commands that return both Chronicle events and command operations are rejected before either runs, because the event batch does not yet take part in operation compensation.
Screenplay (Release v4.30.0): CodeBlockSyntax and SemanticImplementationRequirement compare body line maps by value, so two parses of the same text are equal. Positions do not take part in syntax structural equality, so moving a body inside a document never produces a workspace change on its own.
Screenplay (Release v4.29.0): The reference evaluator does not run policy code. Authorization is evaluated left to right in authored order, as Stage renders it (&&/||) and Arc evaluates it (in declaration order, stopping at the first false): a portable operand that decides first still decides (Portable and Custom denies when Portable denies), but once policy code would run, the outcome is unsupported, never allowed or denied. The same order applies across module, feature and construct gates. A specification whose outcome depends on policy code never passes.
Screenplay (Release v4.29.0): The documented IsAdultCustomer example no longer reads the clock or throws on a malformed claim: it uses context.Occurred and DateTime.TryParse.
Stage (Release v4.11.0): Scoped projection constructs that remain rejected now name their exact blocker in the diagnostic. They are composite keys, all subscriptions, root join removals, nested clear followed by re-creation, child removal across several parents, literal mappings (Cratis/Chronicle#4124), and joins or children inside nested blocks (Cratis/Chronicle#4125). (part of #117)
Chronicle.TypeScript (Release v6.5.0): readModels.getInstanceById is deprecated in favor of findInstanceById; its behavior is unchanged.
Stage (Release v4.10.0): An accepted command with no destination and no stated event source is reported Unsupported(IdentityAllocation) after validation, as in the reference, instead of failing. Projections, queries, given read models and implicit identity allocation remain Unsupported. (part of #15)
Stage (Release v4.9.0): Command properties that feed a constrained event property get a not-null validation rule, so a null value never reaches the unique index (Cratis/Chronicle#4122).
Stage (Release v4.9.0): Projection shapes where Chronicle keys, clears or removes differently from the reference now fail with STAGE-ESM-017. This covers one event contract in several roles at the root, and nested from/clear blocks without a matching root from. It also covers clearing a nested block and then re-creating it, and removing a child joined to several parents.
Stage (Release v4.8.0): The first increment executes commands with explicit-message not empty, minimum and maximum validation, unconditional event mappings, given events with a stated event source, event and rejection assertions, and cancellation. Projections, queries, given read models, authorization, requirements, constraints and identity allocation are reported Unsupported, because Chronicle 19.4.7 cannot run a projection per specification through public APIs. The executor replaces Arc’s process-wide service provider, so run it in its own process, as SpecRunner does. (part of #15)
Screenplay (Release v4.28.0): The MCP server loads attachment contents from its trusted root, so implementation-requirements shows a content hash for each file attachment, and a changed attachment changes its hash. Unchanged attachments reuse the analyzed workspace, and proposals survive an attachment edit.
Screenplay (Release v4.28.0): SemanticDocumentSet.Create normalizes attachment keys, so ./X.cs, .\X.cs and X.cs name the same attachment and hash. Two supplied keys that normalize to the same path with different contents are treated as a conflict, not resolved by picking one.
Screenplay (Release v4.28.0): PlayFileCompiler and the standalone Tool compile syntax only and do not read attachments; the documentation now says so (#244).
Stage (Release v4.7.0): Query arguments typed as a validated concept are rejected with STAGE-ESM-010, because Arc validates them and the reference does not.
Screenplay (Release v4.27.0): ESM v3 now means “ESM with implementation attachments”: a model is v3 when it has a reducer with a body or code validation. Models with neither keep their v1 or v2 bytes exactly.
Screenplay (Release v4.27.0): The reference evaluator cannot run code validation. Executing a command guarded by it, directly or through a concept on one of its properties (including inside composite types and collections), reports an unsupported outcome naming the command or concept and the rule, and a specification that runs it never passes. Authorization is still evaluated first, so a then denied specification on such a command keeps working. Specifications that do not run the command are unaffected.
Screenplay (Release v4.27.0): A model with two validation attachments sharing a requirement id is rejected, as duplicate reducer transitions already were.
Arc.TypeScript (Arc for TypeScript 0.4.1 — observable hosting fixes): Internal ArcServer hosting members are no longer part of the published type declarations; host integrations use @cratis/arc.core/hosting.
Screenplay (Release v4.26.0): The reference runner does not compute reducer state. A specification that reads a reducer-built read model, through given readmodel, then readmodel or then query, reports an unsupported outcome naming the reducer and never passes; other specifications in the model run as before. Calling the evaluator directly reports the same for a query over, or returned state of, a reducer-built read model.
Screenplay (Release v4.26.0): A file-backed implementation attachment is no longer hashed from its path, so moving a file no longer changes its hash and editing it is no longer invisible.
Screenplay (Release v4.26.0): A consumer that accepts only ESM v1 or v2 now receives a v3 model for documents with bodied reducers, where binding used to fail with “requires a portable reducer contract”. Reducers without bodies are still rejected with the same message.
Orleans (Release v1.5.0): Task Resume(JobId) becomes Task<bool> Resume(JobId). A call that ignores the result is unaffected at source level; an implementer of the interface is not. A job that fails to start is a different situation and keeps its existing handling.
Screenplay (Release v4.25.0): A require path qualified with a view the command reads more than once now says to use one of that view’s aliases and lists them, instead of claiming the command does not read the view.
Screenplay (Release v4.25.0): PLAY0175 also reports as, by or reads used as an alias. Aliases, like by properties, are lower-case identifiers.
Screenplay (Release v4.25.0): Decision 0003 notes that its runtime precondition is only partly met (tracked in Cratis/Chronicle#4138).
Arc.TypeScript (Arc for TypeScript 0.4.0 — observable queries and the Arc package layout): Packages are renamed and laid out like Arc on .NET: @cratis/arc.core (was @cratis/arc.server), @cratis/arc.express, @cratis/arc.fastify, @cratis/arc.hono, @cratis/arc.mongodb, @cratis/arc.chronicle (still private and experimental), @cratis/arc.testing (was the @cratis/arc.server/testing export) and @cratis/arc.proxygenerator with the arc-proxygenerator CLI (was @cratis/arc.server.codegen). All source lives under Source/<Package>.
Screenplay (Release v4.24.2): The invoicing sample, the language’s largest example, now declares every read model, type and event it uses and gives its authorized specifications an explicit caller. It binds to the executable semantic model with only the unsupported constructs it shows on purpose left, and a specification pins that list so the sample cannot drift from the language again (#240)
AI (Release v4.0.0): AIProviderApiKey is [Encrypted(EncryptionScope.Namespace)]. Chronicle encrypts it on append and decrypts it on read, keyed per event store namespace — the same boundary the per-tenant protectors it replaces already used.
AI (Release v4.0.0): Command handlers that only awaited the protector are now synchronous.
AI (Release v4.0.0): Cratis.Arc.Chronicle is a direct dependency, which also enables the ARCCHR analyzers. ARCCHR0009 fails the build when a command carries a credential-shaped property that is not excluded from the causation chain.
AI (Release v4.0.0): Twenty event types no longer pass their own name as an explicit [EventType] id. The identifier each one resolves to is unchanged — the type name is the default.
Stage (Release v4.6.0): Update Stage to Cratis/Arc 22.23.0, Chronicle 19.4.7 and Scene 4.2.0. The Host image now bundles the cratis/chronicle:19.4.7-development kernel.
Stage (Release v4.6.0): Generated applications now pin Arc 22.23.0, an explicit Cratis.Chronicle 19.4.7 client with the matching cratis/chronicle:19.4.7-development image, and the Scene 4.2.0 frontend packages.
Stage (Release v4.6.0): Update Cratis.Screenplay and Cratis.Screenplay.CanonicalCorpus to 4.24.0. Specifications may now use then events in any order and exactly, and they render as before. (#128)
Stage (Release v4.6.0): Reject commands and queries that are authorized by a Screenplay policy (STAGE-ESM-015), and specifications that use given caller or then denied (STAGE-ESM-011). The Cratis planner does not render authorization yet, so a rendered application would let any caller through. (#57, #13)
Stage (Release v4.6.0): Update the Billing sample to the fenced inline-code form, because Screenplay 4.24 deprecates the old form (PLAY0397).
Chronicle.TypeScript (Release v6.4.0): Standard-mode schema errors are collected and reported together before the client registers any artifact with the Kernel.
Chronicle.TypeScript (Release v6.4.0): Documentation shows standard-mode @field declarations and labels constructor-property examples as legacy-mode.
Stage (Release v4.5.0): Update Cratis.Screenplay and Cratis.Screenplay.CanonicalCorpus to 4.20.0. (#128)
Stage (Release v4.5.0): Reject ESM v2 constructs the Cratis planner cannot yet render exactly, instead of treating them as v1. Rendering fails with a typed diagnostic in these cases (#128, #13):
Stage (Release v4.5.0): Projections keyed on the event source: STAGE-ESM-008.
Stage (Release v4.5.0): Reject command requirements (STAGE-ESM-005), guarded productions and event tags (STAGE-ESM-006), and append-time constraints (STAGE-ESM-014). The planner does not render these yet, so the generated application would append events the reference evaluator rejects, or tag them differently. (#118, #116)
Stage (Release v4.5.0): Reject validation rules at warning or information severity (STAGE-ESM-005) until the generated validator can report that severity. (#116)
Screenplay (Release v4.24.0): PlayFileWriter.Expand uses the same folder-layout projection as workspace layout changes. folders.md explains which parts of PlayFileCompiler.CompileFolder and WriteTo stay independent of the workspace and why (#137)
Screenplay (Release v4.22.0): Claim types compare case-insensitively; role names and claim values compare exactly; a claim carried more than once matches when any of its values matches. A missing claim, a null target or an unresolvable subject denies. This matches how Arc evaluates authorization through .NET’s ClaimsPrincipal, and Identity.ClaimValue/ClaimValues now look claim types up case-insensitively too (#142)
Screenplay (Release v4.22.0): A specification that exercises an authorized command without a given caller is reported when binding. Caller identity is never inferred (#142)
Screenplay (Release v4.21.0): A file constraint warns (PLAY0396): Chronicle only supports unique constraints, so declare them with unique …, and put other rules in validation or require. The constraints page now states Chronicle’s actual guarantee (#223)
Arc.Kotlin (Release v7.6.0): The JVM parity reference links to the shared C#/Kotlin/Java capability matrix while retaining its implementation evidence (#217).
Screenplay (Release v4.19.0): Canonical printing, folder expansion, MCP expand-layout and propose-ast edits keep comments with the declarations they annotate (#220)
Screenplay (Release v4.19.0): $strings. messages are symbolic string keys in the executable model. A malformed key is reported (PLAY0357), and a reference rejection marks its message as a key (#224)
Screenplay (Release v4.19.0): null in a command or event value is rejected with the reason (PLAY0350): an optional fact is a separate event (#207)
Stage (Release v4.2.0): Reserve the top-level Customizations/ directory for product-owned files. Models that would generate files there, including case variants, now fail with STAGE-CRATIS-005 and no candidate artifacts. (#121)
Stage (Release v4.2.0): Reject malformed or version-mismatched authored Scene payloads with STAGE-CRATIS-001 before producing artifacts. This validates the JSON wire shape, not component bindings or semantic revision provenance. (#100, #13)
Stage (Release v4.2.0): Fail runtime queries when Chronicle returns an unreadable document, rather than silently omitting it and returning partial data. (#10)
AI (Release v3.4.0): A feed post announcing what shipped may carry one plain list of real capabilities inside its argument, with no bolded labels and no slogan per item.
AI (Release v3.4.0): A company account’s copy says “we”, the way the team would say it, instead of the company name in the third person.
Stage (Release v4.1.0): Update Stage and generated applications to Cratis Arc 22.22.0, Chronicle 19.4.4, and Scene 4.1.0. Generated applications explicitly pin their Chronicle client, ASP.NET Core integration, and testing packages to the kernel version.
Stage (Release v4.1.0): Update generated frontends to Components 4.13.1 and Fundamentals 7.19.4.
Screenplay (Release v4.18.0): Canonical printing keeps the authored order of declarations, also through MCP propose-ast edits and folder expansion (#221)
Screenplay (Release v4.18.0): MCP PreserveTrivia edits replace literal values and whole mappings in place at every mapping site, keeping comments and blank lines (#216, #222)
Screenplay (Release v4.18.0): propose-rename is refused only when opaque text actually names the declaration being renamed, and the conflict states the file, line and column (#215)
Screenplay (Release v4.18.0): A projection-level key no longer decides which instance an event updates; key it on from, as Chronicle does (#219)
Screenplay (Release v4.18.0): A reducer without a transition body is reported with guidance to declare a projection instead (#213)
cli (Release v3.14.0): cratis run mounts a Screenplay folder read-only (#128)
cli (Release v3.14.0): cratis run finds .play files in a folder in any casing on every platform (#128)
cli (Release v3.14.0): cratis run rejects a missing path, a file without the .play extension, or a path containing a colon before Docker is started (#128)
Arc (Release v22.21.0): Analyzer ARC0020 now reports an ASP.NET Core authorization attribute only in a project without Arc’s ASP.NET Core integration (Cratis.Arc), since that integration now enforces it (#2719)
AI (Release v3.2.0): ConfiguredAIProvider now projects the Decision Engine provider events (#392)
Arc (Release v22.19.2): Cratis.Chronicle/Cratis.Chronicle.AspNetCore/Cratis.Chronicle.Testing bumped from 18.2.0 to 19.4.2 to pick up [Encrypted] and the read-model release fix it depends on; Cratis.Fundamentals/Cratis.Metrics.Roslyn bumped from 7.19.2 to 7.19.3 alongside it
Chronicle (Release v19.4.2): SecurityJsonSchemaExtensions gains HasSubjectIndependentSecurityMetadata, built on a new predicate-based recursive schema walk in SchemaMetadataExtensions, so Release can tell a namespace-/global-scoped value apart from a subject-scoped ([PII], or [Encrypted] with the default EncryptionScope.Subject) one before deciding whether a missing subject means “nothing to release”
Chronicle.Elixir (Release v3.5.0): cratis_chronicle_contracts bumped from 19.3.2 to 19.4.0
Chronicle.Kotlin (Release v6.4.0): chronicleContractsVersion bumped from 19.3.2 to 19.4.0
Chronicle.TypeScript (Release v6.3.0): @cratis/chronicle.contracts bumped from 19.0.1 to 19.4.0
AI (Release v3.1.2): Tutorials start from the smallest safe setup and a convention-first snippet, and link the paradigm explanation (event sourcing, event modeling) without delaying the first success.
AI (Release v3.1.2): Explanations of what happened after a code block must match the backend the reader actually built.
AI (Release v3.1.2): AI-drafted narrative gets a revision pass against source evidence and voice before it ships.
AI (Release v3.1.2): Coming-from-X pages follow a consistent shape: the reader’s current code, the Cratis equivalent, and what changed. The other technology’s code is accurate at a named version or labeled illustrative.
AI (Release v3.1.2): Diagrams, use-case indexes and diagnostic documentation are asked for where they help, not on every page.
AI (Release v3.1.2): Release notes state verified cross-product pairings, include a fix’s root cause and regression guard as observable behavior, credit external contributors, and state a migration table’s scope without claiming compatibility that was not assessed.
AI (Release v3.1.2): Guidance on how a merged documentation change reaches cratis.io, and that restructuring navigation is not a side effect of writing one page.
AI (Release v3.1.1): The write-documentation prompt and the orchestrator’s documentation step now load cratis-documentation-writing (with cratis-engineering-docs-authoring and cratis-technical-examples) instead of a skill that no longer exists.
AI (Release v3.1.1): cratis-documentation-writing is now also available from the engineering core profile.
AI (Release v3.1.1): Documentation guidance treats Diátaxis as a guide to each page’s primary reader purpose rather than a purity rule. It allows brief supporting context, separate language or host start routes, and page sets scaled to the product.
AI (Release v3.1.1): Example guidance distinguishes partial excerpts from runnable samples and states which snippets the Arc and Chronicle validators actually compile.
Stage (Release v3.22.0): Use Scene 3.7.0 and Components 4.13.0 in generated frontends for editable command and keyed-query forms. (#100)
Stage (Release v3.22.0): Align generated backend and frontend packages on Arc 22.19.1 while retaining the Chronicle 18.2.0 kernel. (#100)
Scene (Release v3.7.0): Require Components 4.13.0 and Arc/Arc React 22.19.1 for the new form contract while retaining Arc-free unbound previews. (#7)
AI (Release v3.1.0): AI setup preserves unrelated MCP servers, settings and comments; conflicting or modified entries are reported instead of overwritten.
cli (Release v3.11.0): Preserve existing MCP servers, comments and unrelated settings during install, update and uninstall. User-owned or modified Screenplay entries are reported as conflicts rather than overwritten.
cli (Release v3.11.0): Keep MCP standard output exclusively JSON-RPC and suppress CLI update checks during a protocol session.
AI (Release v3.0.0): AgentUsageByDay is now a real accumulating projection instead of a [Passive] read model. It previously recomputed a year of buckets with an in-memory GroupBy over every session recorded in the trailing 371-day window on every read, a cost that grows without bound with the number of sessions to answer a question whose answer only changes by one session at a time. AgentUsageByWeek and AgentUsageByMonth were already real projections; the daily model is now keyed and accumulated the same way.
AI (Release v3.0.0): AgentUsageByDay.LastYear now reads the accumulated buckets from its own collection and takes an IMongoCollection<AgentUsageByDay> and a TimeProvider, replacing the previous IRecordedAgentSessions parameter.
AI (Release v3.0.0): AgentUsageByDay now exposes the day as a DayKey and carries BucketKey, CachedTokens and DurationMs; total session time remains available as the Duration property.
AI (Release v2.31.0): Center documentation on reader journeys, intended idioms, minimal first-run setup, and visible results, with source-checked examples and explicit drift checks.
Arc (Release v22.19.0): A query request reader that rejects input as invalid now surfaces as the documented malformedRequest validation failure rather than an exception envelope. Reader failures that are not validation failures are unchanged (#2715)
Arc (Release v22.19.0): The shared HTTP contract documents SSE connection ownership and the sort direction vocabulary as single behaviours, with the remaining narrower difference in what each implementation compares for ownership stated explicitly (#2713)
AI (Release v2.30.0): cratis/documentation gains the writing cadence skill, which applies to documentation equally.
AI (Release v2.30.0): Harness skill-count assertions move from 63 to 65.
Chronicle (Release v19.1.8): IReadModels.Release for a sequence now resolves the schema once for the whole sequence instead of once per instance, and hands the sequence back untouched when the read model carries no compliance metadata at all.
Components (Release v4.11.0): Each <subpath>/styles is self-contained for that subpath — @cratis/components/PivotViewer/styles includes Filter’s rules because PivotViewer renders a FilterPanel, and @cratis/components/DataPage/styles includes the vendored Allotment split-view rules — so there is never a second stylesheet to remember (#301)
Components (Release v4.11.0): Import order between per-area stylesheets does not matter: only styles/base establishes cascade-layer precedence, every area sheet just reopens cratis-components, and the cascade contract is identical whichever entry points are used (#301)
Components (Release v4.11.0): Getting-started and styling documentation now present the per-area path alongside the aggregate, and Documentation/ui-foundation.md records the split instead of the criteria for a future one (#301)
cli (Release v3.9.0): Rendering a Screenplay now produces a full application rather than a backend alone: the generated project gains a frontend that builds, a composed screen, and a module registering its generated proxies against that screen. (Cratis/Stage#100)
Components (Release v4.19.0): FilterPanel uses the overlay container configured by CratisComponentsProvider instead of always portaling to document.body. An unavailable container defers the panel. Inside a modal Dialog, the panel stays within the modal’s focus scope and stays visible to assistive technology, even when the shared overlay container sits outside the modal. (#346)
Components (Release v4.19.0): A filter panel stays aligned with its trigger and within reach while a Dialog animates in, inside a transformed overlay container, and after scroll and resize. Inside a dialog that clips its content, the panel keeps every option reachable. (#346)
Orleans (Release v1.12.2): An ExpandoObject that crosses a silo boundary keeps its shape. Before, every ExpandoObject nested inside it came back on the receiving silo as a Dictionary<string, object>, including a child in a collection or a nested object. Code that looks such a value up by its properties could no longer find them. In Chronicle, this made on-demand read models throw and then return nothing whenever the projection and its cached result ran on different silos (Cratis/Chronicle#4337). What is sent between silos is unchanged, so silos on either side of the upgrade keep working together during a rolling update.
Chronicle (Release v19.14.2): A reactor, reducer, read-model reactor or event type that carries [EventLog]/[EventSequence] is no longer also registered as an empty model-bound projection. Before this, a reactor pinned to an event sequence stopped receiving events. Model-bound read models that use those attributes, including record structs, are still discovered. (#4310)
Chronicle (Release v19.14.2): Synchronous reactor handlers can return arrays and lists of events (SomeEvent[], List<SomeEvent>, IReadOnlyList<SomeEvent>, any single-dimensional array or IEnumerable<T> of known events, EventForEventSourceId or object). Discovery and invocation agree on these return types, and the CHR0054 analyzer no longer reports them as unsupported. Multidimensional arrays are rejected. (#4121)
Chronicle (Release v19.14.2): Release builds of the client and analyzer projects and their specs with 0 warnings.
Chronicle (Release v19.14.2): DotNET.Specs 3,350/3,350 and DotNET.CodeAnalysis.Specs 415/415.
Chronicle (Release v19.14.2): The local CI-equivalent gate is green.
Chronicle (Release v19.14.2): A cross-provider review passed with no remaining findings after two rounds.
cli (Release v3.21.0): cratis chronicle login now saves the token (#118). Before, it reported “Logged in as …” but threw the token away, so every later command fell back to the development client and got 401 from any secured server. Login now fails with a clear error when the server returns no usable token. When a saved token expires, commands report an expired login instead of silently switching to the development client, unless the context has its own client credentials. Tokens and certificate passwords are hidden in --debug, diagnose and workbench output.
Orleans (Release v1.12.1): Cratis.Orleans now depends directly on Orleans 10 Reminders, so the MongoDB provider’s Orleans 9 dependency no longer pulls Microsoft.Orleans.Reminders 9.0.1 into consumers and trips the package’s own alignment guard.
Chronicle (Release v19.4.9-hotfix.1): Hotfix on the 19.4 line for kernels that cannot yet move to 19.13: a replay of a projection no longer leaves its MongoDB read model frozen when the replay ends on more than one kernel silo at once, or overlaps another replay of the same projection. Also carries the replay-context fixes from 19.13.3. 19.13.3 has the same fix for everyone already on 19.13. (#4296)
Chronicle.TypeScript (Release v6.22.1): Append results now carry the constraint name Chronicle returns, so constraint violations, including schema-validation failures, have their constraintId, and configured constraint messages resolve.
Chronicle.TypeScript (Release v6.22.1): The TypeScript appending example shows schema constraint violations and their property paths.
Screenplay (Release v4.44.0): Comments on persona descriptions, query descriptions, constraint headers, unique rules, released by, ignore casing, message, and query by / scoped to lines now stay attached to their line when a document is reformatted or edited.
Chronicle (Release v19.13.3): A replay of a projection no longer leaves its MongoDB read model frozen when the replay ends on more than one kernel silo at once, or overlaps another replay of the same projection. The replay is promoted exactly once, and every silo goes back to writing the read model itself. Before, a silo that lost the race kept sending every live change to replay-<container>, with the observer still reporting Active and no error recorded (#4296)
Chronicle (Release v19.13.3): A replay no longer fails to end because the revert container name from a previous replay of the same read model is reused (#4296)
Chronicle (Release v19.13.3): Starting a replay on several silos at once no longer fails with a duplicate key on replay-contexts (#4296)
cli (Release v3.20.1): cratis new --language help, validation errors and documentation now list C#, Kotlin and Java, including the c# alias. They also state that Kotlin and Java currently require naming the template, for example cratis new cratis --language kotlin.
Chronicle (Release v19.13.2): The MissingImmediateProjectionForModel exception no longer tells you to implement an interface that does not exist.
Arc.TypeScript (v0.41.2): When the PostgreSQL observation manager was disposed without awaiting it and a listener close then failed, the disposal failure surfaced as an unhandled rejection, which can terminate a Node.js process. The failure is now handled internally and still returned to callers that await disposal.
Arc.TypeScript (v0.41.2): The listener manager specs no longer depend on wall-clock timing, which made one of them fail intermittently under load.
Chronicle (Release v19.13.1): WaitForCompletion() no longer fails with an InvalidOperationException when the append result carries event-type tails. The request’s repeated EventTypeTails field defaulted to an array, which protobuf-net cannot add to while decoding, so every non-empty request failed on the server (#4280)
Chronicle (Release v19.13.1): A WaitForCompletion() timeout response that lists outstanding observers now decodes on the client, for the same reason (#4280)
Chronicle (Release v19.13.1): Round-trip specifications under Server.Specs/Contracts/ for non-empty tails, omitted tails and non-empty outstanding observers. The two non-empty cases reproduce the exception without the fix.
Chronicle (Release v19.13.1): All Server specs pass; Release solution build with warnings as errors and formatting pass.
Chronicle (Release v19.13.1): A search of every protobuf-net contract found no other IEnumerable<T> member with an array default.
Arc.TypeScript (v0.41.1): A snapshot query that returns a stream is still rejected with SnapshotStreamError, and Arc now releases the returned value exactly once through the first hook it owns: Symbol.asyncDispose, Symbol.dispose, dispose(), close(), or return() when the value is itself an iterator. Arc never subscribes to it or creates an iterator from it, never calls unsubscribe() (which would close a shared RxJS Subject for every consumer), and never releases values its service container owns. A release failure is reported alongside the rejection, including when the request is cancelled, and a release still running after one second is reported to the server logger. The same rule applies over HTTP and in QueryScenario.
Screenplay (Release v4.42.0): Comments stay attached to their line during canonical printing and expand-layout for the remaining directive lines. These include:
Screenplay (Release v4.42.0): enum values and concept reasons;
Screenplay (Release v4.42.0): policy requirements and persona policies;
Screenplay (Release v4.42.0): UI profile, theme and theme-compatibility lines;
Screenplay (Release v4.42.0): contribution and screen-action labels and order;
Screenplay (Release v4.42.0): the scalar subdirectives in specifications, captures, projections and commands.
Screenplay (Release v4.42.0): Comments on enum and other collection values follow their value when a syntax tree or workspace edit reorders, inserts or removes values.
Chronicle (Release v19.12.0): A MongoDB bulk write that fails part way now applies the remaining operations instead of silently dropping them. Later changes for the partition that failed are held back, so they can’t overtake its replay. Each failed partition is reported once, at its earliest sequence number (#4244)
Chronicle (Release v19.12.0): Forwarding events to another event store’s inbox no longer acknowledges events whose append failed. It stops at the first failure and reports the last event it actually forwarded, so the retry resumes from the failed event (#4259)
Chronicle (Release v19.12.0): Projection keys for immediate (passive) projections round-trip read-model keys that contain # (#4241)
Chronicle (Release v19.12.0): add and subtract projection mappings accept negative, decimal and exponent operands (for example -1, -2.5, 1e-3), and reject malformed operands. Exponent literals and integer literals beyond 2^53 in declarations still depend on the declaration parser (Cratis/Screenplay#285) (#4239)
Chronicle (Release v19.12.0): Composite-key validation for generated declarations resolves the key type from the read model’s Id schema first, so a same-named type elsewhere in the read model can’t be picked by mistake (#4253)
Chronicle (Release v19.11.1): The local Chronicle image starts its embedded MongoDB only when configured to use it; connections to a separate MongoDB or another storage provider no longer start an unused replica set (#4111).
Chronicle (Release v19.11.1): Generating a declarative projection preserves nested mappings, including inner nested blocks and clear with rules. Nested composite keys use the nested read model’s schema while generating their declarations (#4116).
Arc (Release v22.30.0): An authentication scheme or policy supplied by a fallback evaluator is applied before command context values and execution scopes are built, instead of failing every such command (#2751)
Arc (Release v22.30.0): The ambiguity error for conflicting authorization declarations names the conflicting evaluators (#2751)
Arc (Release v22.30.0): Observable queries over collections whose items have no Id send complete snapshots instead of unreliable change sets, and log one warning per subscription explaining that deltas need a stable identity. Collections with an Id are unchanged (#2428)
Arc (Release v22.30.0): The manual query pipeline composition recipe registers AuthorizationDeclarations, which the pipeline needs to authorize queries (#2753)
Chronicle (Release v19.10.1): A projection can clear a nested object and later set it again, including an object nested inside another nested object. The MongoDB sink no longer fails the projection, and the testing engine no longer throws. (#4166)
Chronicle (Release v19.10.1): Clearing a nested object in MongoDB removes the field with $unset instead of storing null. A document already stored with a null parent from an earlier version is repaired before the nested value is written again. The same applies to a nested object inside an array element. The repair only touches that document’s parent, or that one element, and only when it really holds null.
Chronicle (Release v19.10.1): The in-memory sink and the testing engine clear the right property for deeper paths such as outer.info. Clearing an object whose parent is missing no longer creates that parent, which matches MongoDB.
Arc (Release v22.29.0): Command filters continue past non-blocking validation results, so a later Error rejects execution and preflight validation even when an earlier Warning is allowed (#2817).
Arc (Release v22.29.0): Client-side command validation blocks only at the effective severity threshold; non-blocking results remain advisory, server preflight still runs, and CommandForm validity follows the validation verdict.
Arc (Release v22.29.0): Generated validators emit severity calls only for non-Error rules, retaining compatibility with existing client libraries for default rules. Rules with runtime-dependent severity are left to the server. Documentation describes the default-severity assumption at build time.
Arc (Release v22.28.1): Invalid scalar, concept, and collection arguments on GET and QUERY endpoints now return HTTP 400 with a named malformed-request validation error instead of invoking model-bound or controller queries with default values or reporting invalid values as missing. (#2794)
Arc (Release v22.27.2): API path joins collapse repeated separators at segment boundaries without damaging http://, https://, or leading and trailing slashes (#2593)
Arc (Release v22.27.2): Path-prefix hosting guidance now covers apiBasePath, router basename, ASP.NET Core UsePathBase ordering, and Arc.Core static files and fallback (#2593)
Arc (Release v22.27.1): Local functions and other compiler-generated methods inside read models no longer create query endpoints, generated proxies or route conflicts. The runtime, the metadata generator, the proxy generator and the QueryScenario testing helpers apply the same rule (#2651)
Arc (Release v22.27.1): Proxies are no longer generated for query methods returning a collection that is not of the read model, such as string or IEnumerable<Other>, which the runtime never served; covariant collections of a derived read model still get proxies (#2651)
Arc (Release v22.27.1): Multiplexed SSE and WebSocket observable queries keep paging totals on an empty first result and pick up updated totals on later results, without mixing metadata between subscriptions (#2707)
Chronicle.TypeScript (Release v6.16.1): Event-context projection mappings and context-derived keys now reach the kernel in the form it resolves, $eventContext(<Property>), as Chronicle for .NET sends them. Previously declarative toEventContextProperty(...), usingKeyFromContext(...) and usingParentKeyFromContext(...) sent $context.<name>, which the kernel doesn’t recognize, and model-bound @setFromContext(...) sent a bare name that the kernel read as an event content property.
Chronicle.TypeScript (Release v6.16.1): Invalid event-context paths now fail when the projection is registered, naming the projection, read model and path, instead of failing for every event in the kernel. Registration accepts any EventContext property, causedBy.subject, causedBy.name, causedBy.userName and causedBy.onBehalfOf as a whole, and occurred.week(), the kernel’s only derived function. Paths into the causation and tags collections are rejected. The error’s cause, InvalidEventContextPropertyError, is exported.
Chronicle (Release v19.10.0): every mappings, such as count, increment and add, ran twice for join events. They now run once. Existing read models keep their doubled values until you replay the affected projections. Their definitions don’t change, so no replay is triggered automatically.
Arc (Release v22.27.0): ARCCHR0006 recognizes inherited [Replay] handlers when checking whether reactor command execution has a replay decision, including handlers on generic base classes (#2790)
AI (Release v7.1.1): A valid 8,000-character context with 32 labels OOM-killed the published image on the production x86 compute pool (exit 137). Groups of four and even a single 8K label also OOM-killed the 2 GiB Apple Silicon container.
AI (Release v7.1.1): Score labels one at a time; keep the first and last 750 characters of longer inference text. The wire contract still accepts 8K and returns all supplied scores, with documented information-loss/latency trade-offs.
AI (Release v7.1.1): Add tests for long-context truncation and 32-label requests.
AI (Release v7.1.1): Local 2 CPU / 2 GiB Docker test: 8K input with 32 labels returned HTTP 200, all 32 scores, in ~16s without OOM.
AI (Release v7.1.1): Packaged image builds and seven adapter tests pass. Follow-up x86 staging validation is required before merging Infrastructure#82.
Chronicle.TypeScript (Release v6.14.3): A projection definition’s LastUpdated value now changes when a nested mapping changes, such as a property expression inside a from, join, removedWith, child or nested definition. The hash used to drop nested keys, so those changes left LastUpdated unchanged. The kernel compares definitions by structure, so replays were already triggered correctly; only the LastUpdated metadata was wrong.
Chronicle.TypeScript (Release v6.14.2): A property-level @clearWith(Event) on a member of a model-bound child or nested type now clears that member, as in Chronicle for .NET. Previously the TypeScript client registered it as a removal of the whole child or nested object, so the event could remove the object, or match nothing, instead of setting the member to null.
Arc (Release v22.26.1): The NuGet and npm packages for the changes listed in v22.26.0 are published with this release. Publishing v22.26.0 stopped before any package was pushed, because two independently merged changes together broke the TypeScript build; this release contains everything in v22.26.0 and restores the build.
Chronicle.TypeScript (Release v6.14.1): With standard (TC39) decorators, a read model whose mappings are all on properties, such as @setFrom(Event, 'name') without a class-level @fromEvent(...), is now registered when the event store is created, if artifact discovery finds its class or it is registered explicitly. Previously it was registered only after an instance had been created, so queries could fail with “Unknown read model”.
Chronicle.TypeScript (Release v6.14.1): Registering such a model after an instance has been created no longer risks registering it twice.
Chronicle (Release v19.8.1): Composite-key expressions in projection declarations resolve on the kernel. The kernel, the declaration-language generator and the declarative code generator now share one $composite(...) parser. It accepts an optional leading key type name, and spacing between components doesn’t matter. This is part of #4163.
Chronicle (Release v19.8.1): Malformed composite-key expressions fail with a clear error instead of resolving to a wrong key. That covers an invalid type name, duplicate or empty components, and whitespace-only content.
Chronicle (Release v19.8.1): Composite keys that contain characters such as -, @ or : in their mappings are now resolved as composite keys. Previously they fell through to value resolution, which could put every event into one read model instance. If a projection used such a key, replay it after upgrading. New events go to the correct instances, but the old instance stays until you replay.
Components (Release v4.15.1): CommandStepper and StepperCommandDialog now call onChangeStep({ index }) once for every accepted move to a different step: header clicks, Previous, and Next. Previous and Next never reported a change before, and a header click reported one even when the move was then rejected. (#249)
Components (Release v4.15.1): Each stepper panel is now labelled by its step header through aria-labelledby. If you pass pt.header.id, your id is kept and the panel keeps its text label. The wizard stays an ordered list of steps rather than ARIA tabs. (#249)
Components (Release v4.15.1): PivotViewer boolean dimensions now group into true and false columns, and their categorical filters narrow the cards, including the None and Unknown options for missing values. (#334)
Components (Release v4.15.1): PivotViewer keeps missing values missing instead of turning them into the text undefined, and infers each column’s type from its first non-missing value. Missing numbers sort last. Because of this, a numeric column whose first value is missing is now treated as numeric, so a categorical selection on it no longer narrows the cards, as for every other numeric column. (#334)
Components (Release v4.15.1): PivotViewer now applies a dimension’s declared formatValue to column labels and sort to column order. Changing either no longer re-runs the grouping. (#334)
Components (Release v4.15.1): PivotViewer no longer renders an empty viewport after regrouping or filtering when the new layout’s first entries are off-screen. Cards that intersect the viewport are drawn during the transition, and cards that move off-screen are released when it ends. Refs #236: the intermittent crash reported there is not reproduced, so that issue stays open.
Components (Release v4.15.1): A non-modal ChatSidebar can now be rendered open on the server. It portals after mount into the CratisComponentsProvider overlay container, and falls back to document.body when there is none. (#339)
Components (Release v4.15.1): The non-modal ChatSidebar now plays the same open and close animation as the modal one, and skips it when the user prefers reduced motion. (#339)
Chronicle (Release v19.8.0): ReadModelScenario seeds and reads read models through the artifacts provider of its own Defaults, instead of always using the process-wide provider.
Arc (Release v22.23.8): Committing to an aggregate that already had events no longer fails with a concurrency violation when no one else wrote to it. Loading the aggregate left its expected position at zero, so any aggregate whose event source had a later event was rejected on every commit.
Arc (Release v22.23.8): The expected position is now captured before the aggregate’s events are read, so an event appended by someone else while the aggregate is loading is still detected as a conflict at commit instead of being silently overwritten.
Arc (Release v22.23.8): For aggregates without event handlers, IsNew now reflects only the aggregate’s own stream: events for the same event source in other streams no longer make it look existing.
Screenplay (Release v4.41.1): Comments before or on a template’s fits slot line stay with that directive when printed canonically or moved with expand-layout. The typed JSON syntax is unchanged. (#276)
Screenplay (Release v4.41.1): Comments on contribution navigation lines and on declaration and screen file references also stay with their lines.
Components (Release v4.14.3): Published Migrator packages refused to run with a stale-metadata error because their bundled compatibility manifest was still pinned to 4.0.0. Releases now bump every public package to the release version first, regenerate and verify all three compatibility manifests from those versions, and only then publish. A failure in any of those steps stops the release before the first package is published. (#232)
Components (Release v4.14.3): The Migrator’s version mismatch error now names both the package version and the manifest version, and says that the mismatch is a packaging defect. (#232)
Components (Release v4.14.3): The post-publish registry check now also waits for @cratis/components.conformance.
Components (Release v4.14.2): The baseline theme’s forced-colors (high-contrast) tokens now win over the dark-scheme tokens in every scheme state: explicit cratis-dark/cratis-light classes, the OS dark preference, and scoped .cratis-theme sections. Before, high-contrast mode kept the dark palette. (#329)
Components (Release v4.14.2): Page keeps its full-height flex layout when you pass a className; the class is added instead of replacing the layout classes. The panel prop is documented as what it is: a panel class hook on the content region for your own CSS. (#330)
Components (Release v4.14.2): CommandStepper now calls onException and onUnauthorized when a command fails, and turns Submit busy before an async onBeforeExecute runs, so the command can no longer be submitted twice. onFailed now also fires for validation failures, as it already does in CommandDialog and StepperCommandDialog; if you show a generic error from onFailed, it will now also appear for validation failures. (#331)
Components (Release v4.14.2): The Components 3 to 4 change-handler codemod no longer produces an onChange prop on CommandForm fields that fails type-checking. It leaves those call sites unchanged and tells you to move the handler to the enclosing CommandForm’s onFieldChange. onValueChange handlers are still migrated automatically. (#332)
Components (Release v4.14.2): The onbeforeexecute-must-return ESLint rule now checks only the components that transform command values (CommandDialog, StepperCommandDialog, CommandStepper, and Arc’s CommandForm, including aliased and namespace imports), so it no longer reports Arc CommandScope callbacks. (#332)
Components (Release v4.14.2): Corrected public examples and descriptions that did not match the shipped code: the FilterPanel examples now compile, SchemaEditor’s canEdit and DataPage’s onRefresh describe their actual behavior, and the confirmation and busy-indicator dialogs point to Arc’s useConfirmationDialog and useBusyIndicator. (#333)
Chronicle (Release v19.7.11): The kernel no longer registers its MongoDB camel-case convention pack twice (#3589)
Chronicle (Release v19.7.10): A projection declaration containing a block the engine cannot build, such as variant, now fails compilation with a compiler error that points at the block. Before this fix, compilation threw an exception. This also applies when compiling without read model or event schemas and to blocks inside children and nested (#4109)
Chronicle (Release v19.7.9): Watching a read model before the kernel has finished registering it now waits for registration instead of throwing NullReferenceException. If it is never registered, the watch fails with ReadModelNotFound (#3925)
Chronicle (Release v19.7.8): The .NET client now loads a passwordless PKCS#12 client certificate, including its private key, for mutual TLS on .NET 9 and later. Before, it read the file as a plain certificate and lost the key (#3680)
Chronicle (Release v19.7.7): Webhook deliveries that get a non-success HTTP response (4xx or 5xx) now fail the partition and go through the normal failed-partition retry, instead of counting as delivered (#4200)
Chronicle (Release v19.7.5): Append notifications raised by the .NET client now carry each event’s subject: an explicit subject or one resolved from a [Subject] property. Before, they always reported the event source id. This covers single appends, AppendMany and batch appends across event sources (#4133)
Chronicle (Release v19.7.4): The Chronicle health check now reports the failure status it was registered with (for example Degraded) when the kernel is disconnected or unreachable, instead of always reporting Unhealthy (#4201)
Chronicle (Release v19.7.3): The reactor analyzer no longer reports a synchronous EventsWithConcurrencyScopes return, which the runtime supports. It also no longer reports unsupported return types as CHR0004, a parameter error (#4206)
Arc (Release v22.23.7): Generated TypeScript query, observable query and command proxies no longer contain whitespace-only lines, so they pass whitespace lint rules without editing generated files (#2705)
Arc (Release v22.23.6): GET queries honor paging and sorting parameters regardless of casing, so sortBy, sortDirection, page and pageSize sent by the generated TypeScript proxies are applied on both the ASP.NET Core and Arc.Core hosts; ordinary query argument matching is unchanged (#2758)
Chronicle (Release v19.7.2): Literal set-mappings in projection declarations (status = "draft", isActive = true, version = 1, and non-negative numeric add/subtract operands) now project their values. Before this fix they resolved to null. Stored definitions pick up the literal values without migration, but read models built before the fix keep their null values until they are replayed. An empty or otherwise unsupported value expression now fails when the projection is created instead of silently resolving to null (#4124)
Chronicle (Release v19.7.2): Removing a joined child with RemovedWithJoin now removes it from every parent in the in-memory sink and in ReadModelScenario, matching MongoDB. Before this fix the parent that received the event kept the child (#4167)
Arc (Release v22.23.5): ARC0013 no longer reports static members reached through a concept type, such as a NotSet sentinel or a static factory, in validator rules; nullable instance dereferences like RuleFor(c => c.Name.Value) are still reported (#2658)
Arc (Release v22.23.4): Model-bound queries no longer risk binding a dependency to the wrong parameter under concurrent first use. Parameters are classified once when the query is discovered and bound by position, instead of by comparing reflection metadata instances across calls (#2765)
Screenplay (Release v4.39.0): A value indented under a clock trigger (every …, at …) reports PLAY0450, because clock triggers take no values. (#258)
Screenplay (Release v4.39.0): A line indented under a reads line reports PLAY0451. It no longer becomes a property of the command or a value of the reaction trigger. (#259)
Screenplay (Release v4.38.0): The documentation now describes what the executable model binds: one then error per specification, produces … for only on the command’s identifier, and all projections keyed per event source instead of global counters. The shapes it rejects now get clearer diagnostics. (#261)
Components (Release v4.14.1): CommandDialog now applies subtitle, placement, closeIcon, and every other Dialog prop it accepts. Before, these type-checked but were passed to the command form instead of the dialog, so they had no effect. A type-level check now fails the build if a Dialog prop is added without being forwarded.
AuthProxy (Release v2.22.4): An expired session no longer strands a single-page app mid-use. Every unauthenticated request used to get redirected to the sign-in page, even a frontend’s own fetch()/XHR call - the browser followed that redirect silently and handed the caller a plain 200 login page instead of a clear refusal, so a command kept failing without explanation and an identity check could crash trying to parse the page as JSON. A caller that is not navigating a browser now gets a 401 it can act on; an actual page load still redirects to sign-in as before.
Arc (Release v22.23.3): A frontend using useIdentity/IdentityProvider no longer gets stuck showing “not signed in” while the tab stays open. When a session that was active ends server-side (expiry, revoked access) an identity refresh now reloads the page instead of quietly settling into an unset identity nothing on the page could act on - the reload sends the browser through the ordinary sign-in redirect (see Cratis/AuthProxy#136) instead of leaving every command failing silently against a session that is already gone.
Screenplay (Release v4.37.1): Canonical printing and expand-layout keep comments inside form blocks, including @input notes and comments on populate, fields, on submit and inline on behaviors, in order and without duplicates. (#267)
Screenplay (Release v4.37.1): Comments on navigation lines inside screen actions and tables stay with their lines when printed canonically.
cli (Release v3.20.0): cratis render explains why a model whose events declare several generations cannot be rendered yet: alongside Stage’s STAGE-ESM-016, it reports CLI-RENDER-003 naming the evolved event. The command fails with a validation error and writes nothing. Screenplay itself validates such models; Stage does not yet accept their executable model (ESM v4).
Chronicle (Release v19.7.1): CHR0037 no longer reports valid migration chains where two or more generations written with EventTypeGenerationFor belong to the same event type. It still reports generations that resolve to different event types (#4207)
Chronicle.TypeScript (Release v6.11.0): A completion wait no longer leaves its timeout timer queued after it finishes or is canceled.
Chronicle.TypeScript (Release v6.11.0): A stale comment was removed and a sample comment uses American spelling.
Stage (Release v4.18.1): Stage’s semantic runtime now has Chronicle reject its append atomically when another writer appended to the event log after Stage captured the tail, including the first append to an empty log. Before, the append succeeded and the divergence was only detected on the next command. The runtime faults with “the event-log tail changed outside this session”, and nothing is appended.
Stage (Release v4.18.1): An accepted command that appends no facts no longer reports a world that changed during its checks as current.
Stage (Release v4.18.1): Custom IAppendSemanticFacts implementations keep working unchanged; the built-in appender also implements the new IAppendSemanticFactsAtTail, which the runtime uses for the atomic check. Appenders without it keep the previous, non-atomic check.
Arc.TypeScript (Arc for TypeScript 0.30.3 — proxies for commands that can reject): Generating proxies no longer fails with “Multiple unhandled command response types” for commands that return events or a visible value alongside rejected(...) or denied(...). This covers async, union and tuple returns. The rejection branches are not client response values; the client sees them as validation or authorization results, as at runtime.
Templates (Release v1.7.2): cratis --Database PostgreSQL, MsSql, or SQLite: the sample listing now shows registered items. Previously the query failed because the client still sent read models to a MongoDB sink the kernel did not have, and the app connected to a database and user that did not exist. The generated appsettings.json now sets Cratis:Chronicle:DefaultSinkTypeId to SQL and points ConnectionStrings:Cratis at chronicle+<event store>, the database Chronicle projects into
Templates (Release v1.7.2): cratis --Database SQLite now keeps Chronicle’s data in a chronicle-data folder in the project, so the backend can read the read models; it is listed in .gitignore
Templates (Release v1.7.2): cratis-aspire with the default MongoDB database no longer stops at startup, and the backend now connects to the Chronicle container Aspire starts instead of localhost:35000
Templates (Release v1.7.2): cratis-aspire with PostgreSQL, MsSql, or SQLite now starts Chronicle with the development client credentials the backend uses, waits for the database before starting Chronicle, and gives the backend its read-model database
Templates (Release v1.7.2): cratis-aspire SQL variants no longer add Cratis.Arc.MongoDB, and pin Cratis.Arc.EntityFrameworkCore to the current release like the other Cratis packages
Templates (Release v1.7.2): The sample Listing read model now records the event source id it is keyed by, which the listing page uses as its row key
Templates (Release v1.7.2): Every template now produces a .gitignore; NuGet had been dropping it from the packages
Templates (Release v1.7.2): yarn build no longer fails with Yarn 2 and later: the frontend templates include a .yarnrc.yml that sets nodeLinker: node-modules
Chronicle.TypeScript (Release v6.10.0): @setValue(Event, value), .set(...).toValue(value), and constant keys now write their value to the read model. They previously sent a form the kernel did not apply, so the property kept its old value.
Chronicle.TypeScript (Release v6.10.0): Read models with a @nested property, or a declarative .nested(...), now register. The kernel previously failed registration with a NullReferenceException.
Chronicle.TypeScript (Release v6.10.0): Read-model queries (findInstanceById, getInstances, snapshots, watches, and materialized reads) now return every property the model declares. Before, they only returned properties declared with @field. Nested plain classes, ConceptAs values, dates, and booleans are restored as their declared types.
Chronicle.TypeScript (Release v6.10.0): With legacy decorators, an event whose properties are constructor parameters without default values, such as constructor(readonly name: string), now registers with its property types. Before, it regist
Arc.TypeScript (Arc for TypeScript 0.30.2 — Chronicle live lists and late registration): Live Chronicle read-model lists no longer contain an empty entry when observation starts. Arc ignores the kernel’s subscription acknowledgment, which arrives as a change with no key. @cratis/chronicle 6.9.1 also filters it.
Arc.TypeScript (Arc for TypeScript 0.30.2 — Chronicle live lists and late registration): Calling withChronicle(...) after discover(...) or add(...) now works. Before, command and query routes answered 500. An artifact observer added to the application builder now also receives the artifacts registered before it, in registration order.
AI (Release v7.0.1): The Decision Engine no longer restart-loops when many decisions arrive at once. Its liveness and readiness probes queued behind waiting decisions, missed their deadline, and got a busy engine killed as if it had died - so every caller fell back to its default for as long as the backlog lasted. The probes and /metrics now answer immediately however many decisions are waiting.
Chronicle.Elixir (Release v3.5.1): Projections map multi-word event fields. Events are stored as camelCase JSON, but projection expressions sent atoms such as :owner_name as-is, so those fields were never set, with no error. Atom field references and key expressions are now sent as camelCase; a join’s on: still names the read model property. Multi-word fields that the event and read model share are mapped automatically, following the kernel’s own AutoMap rules: not for a from that only aggregates, never over an explicit mapping or a no_auto_map field, and never from an event field a join’s explicit mapping already reads.
Chronicle.Elixir (Release v3.5.1): Boolean and float constants in projections work.set: [on_loan: true] was sent as a field name and never applied. It is now sent as a constant, like integers already were.
Chronicle.Elixir (Release v3.5.1): Reducers register. Every registration attempt failed with an UndefinedFunctionError for Cratis.Chronicle.Contracts.Observation.Reducers.SinkDefinition, so no reducer ever ran and its read model read as {:ok, nil}.
Chronicle.Elixir (Release v3.5.1): Constraints with remove_constraint register. The releasing event type was sent in a form the contract can’t encode. Because constraints register before read models and projections, one such constraint stopped the whole client fro
Stage (Release v4.18.0): A model that declares event generations (Screenplay 4.34) now fails with STAGE-EVENT-001, naming the event, on every path that reads events from syntax, instead of rendering one generation’s shape as if it were the current event. (#160)
Chronicle.TypeScript (Release v6.9.1): watch() skips the kernel’s subscription acknowledgment, as the .NET client does. Before, every new watch began with an empty changeset that had no key and no read model. Consumers that built lists from the changesets got an empty entry. Normal changes and removals are unaffected.
Arc (Release v22.23.2): CommandScenario<TCommand> no longer replaces Arc’s process-wide service provider. A host that runs in-process specs keeps resolving services from its own provider after a scenario is disposed, and overlapping scenarios no longer interfere with each other (#2763)
Chronicle (Release v19.7.0): Jobs could not be written on PostgreSQL at all: the state column is jsonb, which refuses an implicit cast from text. Starting a job still reported success because the failure was inside the grain’s write, so the kernel believed it had started work that never existed - a failed partition was never retried, and a redaction’s replay never ran (fixed in Cratis.Orleans 1.10.1)
Chronicle (Release v19.7.0): The SQL job storage shipped a context it could not create tables for, and the MongoDB one never registered the conventions its own queries assumed, so writes and reads disagreed on casing (fixed in Cratis.Orleans 1.6.1)
Templates (Release v1.7.1): The generated READMEs gave the wrong frontend port: the Vite dev server runs on http://localhost:9000, not 5173, and run.sh in the Kotlin and Java templates now prints the right port
Templates (Release v1.7.1): The documentation pointed to dotnet new cratis-kotlin and dotnet new cratis-java, which do not exist. The command is dotnet new cratis --language Kotlin or --language Java, and Cratis.Templates already includes both
Templates (Release v1.7.1): The documentation stated fixed versions for the Kotlin and Java templates (Arc 7.2.0 with Chronicle 4.0.0), but those templates resolve the latest Cratis release when they build
Templates (Release v1.7.1): cratis new examples now include the required --language option
Templates (Release v1.7.1): The TypeScript command example in the web template documentation now compiles against the generated proxy
Templates (Release v1.7.1): The Aspire template README gave a fixed dashboard address; Aspire prints a dashboard link with a login token and a different port each run
Templates (Release v1.7.1): Links in the generated READMEs that pointed to retired cratis.io/docs/... pages now point to the current Arc, Chronicle, and template documentation
Templates (Release v1.7.1): The AI setup table listed the wrong profile for the Java template; it uses cratis/application/java
Templates (Release v1.7.1): The generated READMEs and documentation now describe known problems in the templates:
Templates (Release v1.7.1): With the Yarn 2+ default Plug’n’Play mode, yarn build fails. Add nodeLinker: node-modules to fix it
Templates (Release v1.7.1): The default MongoDB variant of cratis-aspire stops at startup
Templates (Release v1.7.1): Read-model queries fail in the PostgreSQL variant of cratis
Templates (Release v1.7.1): The cratis-aspire SQL variants keep Cratis.Arc.EntityFrameworkCore unpinned
Chronicle.TypeScript (Release v6.8.0): Two @constraint classes with the same id now fail at registration. Before, the last one silently replaced the first.
Chronicle.TypeScript (Release v6.8.0): Merging same-named constraints with conflicting scopes or ignore-casing settings now fails with a clear error.
Chronicle.TypeScript (Release v6.8.0): The first message supplied among same-named unique event type declarations is kept.
Chronicle.TypeScript (Release v6.8.0): A $ in a violation value is inserted literally into the message.
Arc (Release v22.23.1): An EventForEventSourceId returned from a command now keeps its Occurred and Tags when appended, for a single wrapper, a collection or mixed collection of wrappers, and EventsWithConcurrencyScopes, on both the transactional and the immediate append path. Previously both values were silently dropped, so imported or backfilled events were recorded with the append time and without their per-event tags (#2570)
cli (Release v3.19.0): clear-quarantine failed against every kernel it was ever pointed at: it resolved its contract method by reflection, which cannot see explicitly implemented interface members, and the generated client implements the contract explicitly. It now calls the contract method directly (#185)
cli (Release v3.19.0): retry-partition reported that a retry had started regardless of what the kernel actually did. It now reads the outcome the kernel reports and exits non-zero when the observer or the partition is quarantined, or the partition was not among the observer’s failures, instead of leaving the impression that recovery was under way (#186)
Arc.TypeScript (Arc for TypeScript 0.29.0 — query paging, sorting and QUERY bodies like .NET): An unpaged request to a MongoDB or Drizzle query that needs paging no longer fails with a 500. It returns the complete result, up to the provider’s maximum page size. Arc on .NET returns every row; this bound is a documented deliberate difference.
Chronicle (Release v19.6.1): Restored the Chronicle release pipeline: adding IObservers Observers to IEventStore as a required member broke the actual publish, because an existing external implementation of IEventStore (Arc’s CommandScenario test harness) was compiled against the interface before this member existed, and does not have it. A type that implements an interface has to implement all of it, or the runtime refuses to load it before any of its own code runs — which is exactly what happened when the release pipeline tried to start Chronicle 19.5.0 beside the currently published Arc packages.
Chronicle (Release v19.6.1): Observers is now an optional interface member with a default implementation that throws ObserversNotSupported, the same shape IPatterns Patterns/PatternsNotSupported already use on this interface for the identical reason. Every real implementation continues to provide it explicitly and is unaffected.
AI (Release v6.3.2): The Decision Engine no longer answers the first decision after an idle spell in seconds instead of milliseconds. Model weights are now held in process memory instead of memory-mapped page cache the node could reclaim, and a warm-up decision is scored before /readyz reports ready, so a ready pod stays at full speed for as long as it runs.
Chronicle (Release v19.6.0): CHR0024 no longer reports a [Nested] projection object as having no mapping source. The attribute was missing from the analyzer’s set of recognized mapping attributes, so every nested object was reported as one that would never be populated (#4175)
Chronicle (Release v19.6.0): CHR0024 no longer reports the properties of a [ChildrenFrom<TEvent>] child record as unmapped. The events that populate a child are named by its parent, but the child was judged against only its own attributes and so against an empty set of subscribed events (#4176)
AI (Release v6.3.1): The provider Configuring namespace is now reachable from the package root as import { Configuring } from '@cratis/ai'. It was left out of the barrel because its command names collide with those in Adding, Reconfiguring, Removing and Renaming, with a comment directing consumers to import it by path — but the package’s exports map exposes only the root entry, so no deep path resolves and the namespace could not be reached at all. It goes out under its own namespace, which carries it without reintroducing the ambiguity
Chronicle.TypeScript (Release v6.7.1): An inferred variant read model now uses the model’s own members when its shared-handler mappings are validated.
AI (Release v6.3.0): Removed the advice that reads plus concurrency protects a decision. The executable model rejects both (PLAY0271).
AI (Release v6.3.0): Removed the projection-level key from the examples. It routes nothing (PLAY0381).
AI (Release v6.3.0): Binding no longer implies the reference runner will run a model. The skills list the projection constructs the reference execution plan refuses: a projection-level remove via join, all beside removals, children or nested, join/children/remove via join inside nested, and event-context values other than the event source identity. One of these stops every specification in the
Arc.TypeScript (Arc for TypeScript 0.26.1 — standalone host peer addresses): The standalone host (app.run(), runArc and createArcNodeHandler) now passes each request’s socket peer address to Arc. Before, two things went wrong for anonymous callers:
Screenplay (Release v4.32.0): find-assertion-gaps no longer reports a slice whose only assertion is then denied as unasserted.
Screenplay (Release v4.32.0): References and dependencies to an appended event are labelled whenAppendedEvent instead of thenEvent.
Screenplay (Release v4.32.0): The server’s initialize instructions say identities persist when a proposal is applied; export-workspace is optional, for transfer or backup.
Stage (Release v4.16.2): Stage’s in-memory runtime and specification executor report an opaque policy they reach as unsupported instead of allowing or denying it, following authored order: a portable operand that decides first still decides (Screenplay decision 0005).
Stage (Release v4.16.2): An unsupported authorization result is no longer replaced by a contract rejection when the command payload fails to bind.
Arc.TypeScript (Arc for TypeScript 0.24.1 — anonymous live queries over SSE): Live queries work for anonymous callers over the SSE hub, the transport the @cratis/arc.react<Arc> provider uses by default, as they do with Arc on .NET. Previously the SSE hub accepted only authenticated callers, so observable queries in anonymous applications stayed empty unless the client switched to WebSockets.
Arc.TypeScript (Arc for TypeScript 0.21.1 — proxy response types): Generated command proxies no longer declare Chronicle events, event wrappers, aggregate commit results or command operations returned from handle() as the command response. The response is the one value the server sends back, or void when every returned value is handled on the server, as with Arc on .NET.
AI (Release v6.2.0): Twenty-eight generated proxy folders were unreachable from @cratis/ai. Agents, skills, provider pools, model discovery, tier mapping, Codex, Copilot, rate limiting and usage snapshots all generate proxies, but the package root’s hand-maintained barrel had no export line for them, so importing any of them failed as a missing export rather than as a build error.
Orleans (Release v1.6.1): The new Orleans.Storage.Sql.Specs project was multi-targeted along with everything else, but the provider it specifies is net10.0 only because EF Core 10 is. Restore failed with NU1201 on a project reference that cannot resolve for net8.0/net9.0. It now carries the same IsPackaging condition the provider itself uses.
Orleans (Release v1.6.1): ConventionPacks used System.Threading.Lock, which does not exist on net8.0. Now a plain object, with the reason recorded next to it.
Orleans (Release v1.6.0): SQL jobs storage now creates its own schema. The provider shipped a JobsDbContext with no migrations, and nothing else in the package created the tables, so provisioning silently fell to whoever consumed it - and a consumer that did not know to do it got a database where every job read and write failed with relation "Jobs" does not exist. A v1_0_0 migration creates Jobs and JobSteps, and SqlJobsStorage.GetFor applies it before handing back storage. The column helpers come from Cratis.Arc.EntityFrameworkCore, so one migration is valid across SQL Server, PostgreSQL and SQLite.
Orleans (Release v1.6.0): MongoDB jobs storage now registers its own convention pack. It declared one by implementing ICanProvideMongoDBConventionPacks, but nothing ever called Provide(), so state serialized with Pascal-case element names while every filter was written against camel case - including the composite _id. No filter matched: reads returned empty and upserts were rejected for altering an immutable _id. A failed job step was written and then could not be found, which is indistinguishable from a job that never had steps.
Orleans (Release v1.6.0): Job and job step state are read back as their base types, but what is written is the consumer’s own subclass. The first extra property made the read throw, so a job authored the way the documentation shows could never have its steps read. IgnoreExtraElementsConvention added to the same pack.
Chronicle.TypeScript (Release v6.5.1): readModels.findInstanceById returns null when the Kernel answers a missing read model with a JSON null document, instead of throwing.
Screenplay (Release v4.29.0): A command or query with two or more authorize lines kept only the last one, so every earlier gate was silently dropped. The lines now combine with AND in authored order, as module and feature gates already did and as the documentation states. Printing writes them as one authorize A and B line. This makes such commands and queries stricter.
Screenplay (Release v4.29.0): A policy with two require lines silently kept only the last condition. This is now PLAY0441.
Screenplay (Release v4.29.0): A policy combining require with code bound only the code and dropped the condition once policies with code were admitted; this is now PLAY0440 at parse time.
Arc.TypeScript (Arc for TypeScript 0.8.0 — MongoDB integration): MongoReadModels.queryPage applies Arc’s requested sort before the application’s own sort, so the order it reports is the order it returns.
Chronicle.TypeScript (Release v6.5.0): appendMany sends every supplied concurrency scope label, not only the scopes derived from the events’ event source ids.
Chronicle.TypeScript (Release v6.5.0): An event store now uses the clientArtifactsProvider configured in ChronicleOptions instead of always using the default artifact discovery.
Chronicle.TypeScript (Release v6.5.0): Causation links added while appending no longer leak into sibling operations.
Fundamentals (Release v7.19.6): TypeScript projects that use "moduleResolution": "NodeNext" (Node.js ESM servers and libraries) can now import @cratis/fundamentals and its geospatial, json and reflection subpaths with full type checking. The published declarations use resolvable .js import paths, and each entry point resolves the ESM or CommonJS declarations that match the module format being loaded.
Stage (Release v4.7.1): A generated application’s event store data now survives docker compose down and up, container recreation and regenerating the application into the same folder. The generated docker-compose.yml keeps the development Chronicle image’s MongoDB data in the named volumes chronicle-data and chronicle-config; before, it used anonymous volumes and a recreated container started from an empty store. Only docker compose down --volumes deletes the data. (part of #100)
Stage (Release v4.7.0): The legacy syntax renderer no longer renders [AllowAnonymous] for a command or query that inherits authorize from its module or feature. It now fails with AuthorizationCannotBeRendered.
Screenplay (Release v4.27.0): An ESM v3 model (released in v4.26.0 for reducers with a body) lost v2 execution semantics: produced facts carried no event-source context, so then <Event> for … assertions failed, and a mismatched typed when … for was not rejected. v3 models now execute with all v2 semantics, as documented.
Components (Release v4.14.0): The column filter trigger rendered U+2315 TELEPHONE RECORDER in a span at the ambient font size, so it showed as a tiny mark that does not read as a filter. It is now a funnel SVG sized against the header row.
Arc.TypeScript (Arc for TypeScript 0.4.1 — observable hosting fixes): Closing an SSE hub connection while a subscription is still opening no longer crashes the process with an unhandled rejection after the shutdown timeout.
Arc.TypeScript (Arc for TypeScript 0.4.1 — observable hosting fixes): mountFastifyWebSockets no longer hides boot errors from plugins registered before it, so a Fastify app whose authentication plugin fails to load no longer starts serving. The mount now also works whether @fastify/websocket is registered before or after it.
Arc.TypeScript (Arc for TypeScript 0.4.1 — observable hosting fixes): The standalone host (runArc) now applies its native callback to WebSocket upgrades too, so host-authenticated principals, the request authority and the remote address are the same over WebSocket as over HTTP.
Arc.TypeScript (Arc for TypeScript 0.4.1 — observable hosting fixes): runArc’s close() stops accepting connections first and finishes within its timeout, even when a direct WebSocket query never finishes opening.
Arc.TypeScript (Arc for TypeScript 0.4.1 — observable hosting fixes): Oversized inbound WebSocket frames are rejected with close code 1009 even when the app shares its own @fastify/websocket or @hono/node-ws server with Arc.
Chronicle (Release v19.4.8): Cratis.Chronicle now carries Cratis.Chronicle.CodeAnalysis as a package dependency, so a consumer actually receives the CHR analyzers. The analyzer project packed itself while setting DevelopmentDependency, which NuGet reads as “never emit me as a dependency” — so the client’s nuspec never mentioned it and a consumer had to know the package existed and reference it by hand. The package identity moves into a package-only project the client can depend on, the same shape Cratis.Arc.Chronicle already uses for its ARCCHR analyzers.
Orleans (Release v1.5.0): IJobsManager.Resume reports whether the job was actually taken forward. Resuming is allowed to refuse - the job was never prepared, or its owner is no longer interested - and Resume computed that refusal, logged it, and returned void, so a caller could not tell a refusal from a resume. Nothing takes a refused job: it stays Stopped, so it will not run, will not finalize, and will never report back, and a caller that treats that as success waits forever for something that is not coming.
Stage (Release v4.6.2): A command in the sandbox runtime no longer reports success when Chronicle rejects its events. A constraint violation now fails the command with the constraint’s name and message as a validation failure. A schema rejection or any other append error fails it with an error. Before, the rejection was only logged, so nothing was appended and read models stayed empty while the command said it had succeeded. (#10)
Stage (Release v4.6.2): $context.tenant and $context.causedBy.subject, .name and .userName in produced event mappings now resolve to the current tenant and caller. A produced mapping the runtime cannot resolve now fails the command instead of being dropped from the event. (#10)
Fundamentals (Release v7.19.5): JsonSerializer.deserialize now fills arrays declared as @field(Array, { genericArguments: [ItemType] }), the form standard-decorator code uses. Items are deserialized as ItemType, including concepts and nested models; before, such an array came back empty.
Fundamentals (Release v7.19.5): A concept that declares static readonly valueType (for example Guid) now receives its value converted to that type, so a ConceptAs<Guid> holds a Guid instead of a string.
Fundamentals (Release v7.19.5): Falsy payload values ("", 0, false) are deserialized through their field type, so a concept field holding an empty string or zero is wrapped in its concept like any other value.
Screenplay (Release v4.24.2): A specification that uses a read model with no keyed query in given readmodel or then readmodel no longer reports a second error, “must state its identifier property ””, at every block. The one error where the read model is declared, which says why it cannot be identified, remains.
Screenplay (Release v4.24.1): An MCP apply that renames a document only by case now succeeds and leaves the file with the new casing on disk. A destination is allowed only when it is the same on-disk entry as the document being moved away. A different file whose name differs only by case is still refused, and a failed case-only rename rolls back to the original name.
Chronicle.TypeScript (Release v6.4.0): Member-less events and read models work in standard mode.
Chronicle.TypeScript (Release v6.4.0): An explicit @field(Object) keeps its object schema, and concepts and Guids are recognized across duplicate @cratis/fundamentals copies.
Stage (Release v4.5.0): State the payment summary identifier in the Billing sample’s payment-list specification. Screenplay now requires it (PLAY0351). (#124)
Orleans (Release v1.4.2): NullJob collided with Chronicle’s NullJob the same way JobsManager did, so a silo referencing both libraries still could not start
Chronicle.TypeScript (Release v6.3.2): Load @cratis/chronicle and every exported subpath directly in Node.js ESM without a bundler. Published JavaScript and declaration files now use explicit .js file specifiers, and each build verifies the packed package imports natively.
Chronicle.TypeScript (Release v6.3.2): Preserve constraint violations and errors when a batch append is rejected before sequence numbers are assigned, so a rejected batch no longer reports an empty result set.
Orleans (Release v1.4.1): A silo referencing both Cratis.Orleans and Cratis.Chronicle could not start, because both ship a JobsManager grain and Orleans gave them the same derived grain type name (#16)
Screenplay (Release v4.20.0): A preserved comment stays with its own declaration, even when two declarations in the same scope print identical lines (#229)
Chronicle (Release v19.4.7): An observer whose stopped catch-up job refused to resume was left believing catch-up was under way — dropping every live event, never advancing, and eventually quarantined for a strand it could not escape
Arc (Release v22.23.0): Observable streams retain their identity and service lifetime through in-flight emissions, including disconnects and failing cancellation or disposal callbacks.
Arc (Release v22.23.0): Authorization diagnostics now describe contradictory attributes accurately; ARC0021 is limited to authentication schemes without Arc’s ASP.NET Core integration.
Arc.Kotlin (Release v7.6.0): Corrected the parity reference: Arc .NET rejects contradictory authorization attributes in either evaluator order, and its generated proxies support XML documentation comments.
Stage (Release v4.2.0): Bind Chronicle’s lowercase read-model identity for live by-id queries while preserving modeled Id and ID fields. Normalize numeric, boolean, and composite identities for consistent readback. (#10)
Stage (Release v4.1.0): Reject unsupported ESM kinds and value combinations with a typed diagnostic and no candidate artifacts, instead of emitting placeholder types, default values, or silently omitting slices. (#123)
Stage (Release v4.1.0): Preserve Chronicle projection mapping replacement, recursive child mappings, and auto-map inheritance. Legacy rendering now fails when it cannot preserve the modeled projection rather than producing incomplete code. This does not add support for new ESM constructs. (#125)
Stage (Release v4.1.0): Reject ambiguous runtime projection keys before startup or remote registration, preventing keys from silently resolving to an unrelated value.
Stage (Release v4.1.0): Correct the Billing sample’s customer-name and cancellation fields, validate issuance against the invoice’s read state, and replace its empty state reducer with a projection. (#124)
Screenplay (Release v4.18.0): An import of a declaration from the same application no longer hides consistency diagnostics (#208)
Screenplay (Release v4.18.0): A dotted path that continues past a scalar, concept or enum field is reported (PLAY0282/PLAY0287) instead of compiling silently (#201)
Chronicle.TypeScript (Release v6.3.1): Repeated removedWith() calls on a unique property constraint now retain every distinct release event, so any declared event can free the value instead of only the last one (#77).
Chronicle.TypeScript (Release v6.3.1): Unique event-type release examples now explicitly state that the TypeScript client does not support that workflow, rather than demonstrating a constraint that enforced nothing.
AI (Release v3.3.1): Cratis corpus agents inherit the model selected for the session instead of overriding it with outdated Claude model IDs, in every harness. (#396)
AI (Release v3.3.1): Pi no longer offers two delegation tools when another extension already provides Agent (such as pi-subagents, which reads the same .pi/agents): the Cratis subagent tool stands down for that session and says so once. Without such a tool it works as before.
Chronicle (Release v19.4.6): A failed partition is now retried within the retry interval even if the first retry reminder tick is lost. Previously the next attempt could be deferred by the 48-hour reminder period. (#4113)
Chronicle (Release v19.4.6): SQL storage (PostgreSQL, SQL Server, SQLite) now loads and refreshes reminders from storage correctly. Range reads follow the Orleans reminder table contract, and reminders stored by earlier versions are rehashed on startup. (#4113)
Chronicle (Release v19.4.6): The SQL reminder table now returns the stored ETag when a reminder is registered, and returns nothing instead of failing when a reminder does not exist. (#4113)
Chronicle (Release v19.4.5): A projection whose children use a constant parent key now applies every event to them, not just the ones that create them. Previously, when the root carried event types of its own, later events for an existing child were dropped: a fixed-key document counting things kept an accurate root total while updates and removals to its children went nowhere, so a count of what was still open kept counting things that had closed. Creations still landed, so the document looked healthy. (#4105)
Chronicle (Release v19.4.5): A projection can now combine a root-level constant key with constant-parent-key children in one read model. It previously failed to resolve the child’s parent, forcing the total and the membership set into separate read models. (#4099)
Chronicle (Release v19.4.4): Seeding a projection-backed ReadModelScenario with an initial state containing a nonempty JsonObject no longer crashes the test host with a stack overflow (#3993)
Chronicle.Mcp (Release v1.4.0): Merges to main publish again. The publish trigger’s path filter matched only a file named main, so no labeled merge since the switch to releasing on push (#20) produced a release.
AuthProxy (Release v2.22.3): The 43 <c> elements in XML documentation that had no language attribute now declare language="text", matching the rest of the codebase and keeping MA0219 clean.
Fundamentals (Release v7.19.4): API documentation uses the standard @public tag instead of @export, and the decorator context types are marked @inline.
Fundamentals (Release v7.19.4): References to Date link to its MDN page, so they resolve in the generated API documentation.
Fundamentals (Release v7.19.4): Remove a stale lint suppression and add the blank lines the markdown lint expects.
Arc (Release v22.21.0): The authorization attribute evaluator specs could not fail: a null-conditional assertion skipped the assertion whenever the evaluator found nothing
AI (Release v3.2.1): The Decision Engine image did not build at all
Chronicle (Release v19.4.3): An observer could be left permanently believing it was preparing catch-up — dropping every live event, never advancing, and eventually quarantined — when its catch-up job concluded without having prepared steps of its own
Chronicle (Release v19.4.3): a job that was already running,
Chronicle (Release v19.4.3): a stopped job that was merely resumed,
Chronicle (Release v19.4.3): a job found with every step already completed, which is finalized rather than resumed.
cli (Release v3.13.2): The <READ_MODEL> argument is described as the read model identifier and names the column to read it from, matching what the commands actually send.
cli (Release v3.13.2): No behaviour change: the wire value was always ReadModelIdentifier. This aligns the [Description], the [LlmOption] metadata and the settings doc comment with it.
cli (Release v3.13.2): The server side of the same mistake is fixed separately in Cratis/Chronicle fix/read-model-lookup-miss-guard, which turns the resulting NullReferenceException into a meaningful error. The two are independent; either can merge first.
cli (Release v3.13.2): GetReadModelInstancesCommand catches an RPC error whose detail contains "NullReferenceException" and reports it as “read model is client-owned”. That was papering over the server defect above and is the wrong explanation for an unknown identifier — worth re-scoping once the Chronicle fix ships. Left untouched here.
cli (Release v3.13.2): read-models occurrences uses a different argument name (<READ_MODEL_TYPE>) and may be worth a consistency pass.
cli (Release v3.13.2): New spec asserts the description says identifier, does not say container name, and names the Identifier column that ListReadModelsCommand prints — so help text and wire payload cannot drift apart again.
Arc (Release v22.19.2): A read model injected into a command’s Handle(), Provide(), or a CommandValidator<T> is now released (its [PII]/[Encrypted] properties decrypted) regardless of whether the command declares a Subject/[Subject]/ICanProvideSubject — most commands rely on Chronicle’s implicit event-source-id subject fallback instead, which was never checked, so release was silently skipped for the common case independent of what the injected read model actually carried
Arc (Release v22.19.2): A namespace- or global-scoped [Encrypted] value (Cratis/Chronicle#4095) now reaches release correctly even on a read model that has no Id/[Subject] at all — the ordinary shape for that kind of value, since its key does not depend on a subject
Chronicle (Release v19.4.2): IReadModels.Release no longer skips a namespace- or global-scoped [Encrypted] value on a read model that has no resolvable subject (no [Subject] property and no Id property) — that scope’s key does not depend on a subject at all, and a read model carrying only that kind of value ordinarily has no subject-identifying property in the first place (Cratis/Chronicle#4095)
Chronicle.Elixir (Release v3.5.0): Chronicle.Connections.AppendCompatibility’s announced protocol version was still pinned to 19.0.1 while mix.lock had already moved to 19.3.2
Chronicle (Release v19.4.1): A kernel with a large artifact set could no longer start. Registering projections awaited a reconciliation pass whose cost scales with projections × namespaces, inside the caller’s response timeout, so every registration timed out and the silo never became ready. Registration now schedules that pass instead of awaiting it. (#4088)
AI (Release v3.1.1): New documentation pages are again added to the product’s toc.yml, so they no longer silently drop out of the sidebar.
AI (Release v3.1.1): Writing guidance no longer asks authors to hand-maintain page edit links that the documentation site now generates.
Stage (Release v3.22.0): Include the component stylesheet and its font assets in generated frontend bundles. (#100)
Screenplay (Release v4.15.0): Preserve module forms and module/feature contributions exactly once when expanding and merging model folders. (#202)
Screenplay (Release v4.15.0): Report unsupported query-key combinations as diagnostics instead of throwing, and reject executable-only no-op transactions on non-executable workspaces.
Chronicle (Release v19.3.2): Cratis:Chronicle:Clustering:ResponseTimeout now governs the call it was added for. A grain service is a system target, and Orleans times system target calls out against SystemResponseTimeout rather than ResponseTimeout, so registering projections from the startup task stayed on the 30 second default while the setting appeared to have been applied. (#4088)
Arc (Release v22.19.1): Prevent CommandForm from executing while custom field validation errors are present, including immediate and imperative submissions. (#2723)
Arc (Release v22.19.1): Keep validation messages and displayed submission results consistent when custom errors change or clear. (#2723)
AI (Release v2.31.0): Resolve conflicting tutorial and snippet guidance and remove handoffs to nonexistent documentation skills.
AI (Release v2.31.0): Clarify release-intent authority and the limits of static skill verification.
Arc (Release v22.19.0): sortDirection=descending sorted ascending. asc, ascending, desc and descending are all accepted case-insensitively now, and any other value is rejected as malformedRequest with 400 instead of being answered in the opposite order to the one asked for (#2715)
Chronicle (Release v19.3.1): Cratis:Chronicle:Clustering:ResponseTimeout now also applies to the calls it was added for. A silo hosts a client of its own, and the startup task reaches its grain services through that hosted client, so those calls take the client’s timeout rather than the silo’s — which left the startup path that needs the larger budget still running on Orleans’ 30 second default and made the setting look like it did nothing. (#4088)
Chronicle (Release v19.2.2): A Chronicle kernel could reach a state where it was unable to start at all. Registering the persisted projection definitions was the one startup step that did not retry, and it is the step likeliest to exceed the response timeout, because registering fans a subscribe out across every observer in the store rather than doing a single grain’s work — so the time it needs grows with the store. Once a store grew past that point the timeout terminated the host, the next attempt hit the same wall, and the kernel stayed down until someone intervened. (#4088)
Chronicle (Release v19.2.2): The Week calendar accessor is now an extension method. It shipped as an extension property, which cannot be used for the one thing it exists for — the language does not permit an extension property inside an expression tree, and these accessors are only ever written inside one. A path built with it is now also rendered as the bare name rather than with a trailing (), matching the name the registry is keyed by; the parenthesized form is still accepted when parsing.
Arc (Release v22.18.0): AuthenticationMiddleware now sets the matched endpoint’s metadata on the request context before any IAuthenticationHandler runs, so a handler can check context.AllowsAnonymous() and return AuthenticationResult.Anonymous instead of rejecting - and logging a rejection for - a request the endpoint never required a credential for, such as a Kubernetes health probe (#2706)
Chronicle (Release v19.1.8): Reading a collection of read models no longer regenerates the same JSON schema once per row. Generating a schema is a function of the CLR type alone, so it is now generated once per type and shared. The compliance release pass asked for it per instance, which made serving a collection of read models — every emission of an observable query, for every subscriber — spend time proportional to the number of rows on work that produces an identical answer each time. Measured at 328 ms for 916 rows of a moderately sized read model, now effectively zero.
Arc (Release v22.17.0): An observable collection query backed by MongoDB no longer costs time proportional to the size of the collection every time a single document changes. The change stream already names the changed document, and the observable already decides what that meant for the observed set; that verdict is now carried on the emission instead of being discarded and then rediscovered by serializing every item of the new snapshot and the previous one.
Arc (Release v22.17.0): The comparison fallback no longer serializes every item twice on every emission. Unchanged items are the very same instances the previous snapshot held, so reference equality settles most comparisons and record value equality settles the rest; serializing is now the last resort for an item type that overrides neither.
Arc (Release v22.17.0): Removing an item from a paged observable query now reports the document pulled onto the page to replace it, so a client applying the delta no longer ends up one row short.
Stage (Release v3.21.2): Synchronize the Stage Host kernel with updated Chronicle clients, verify the exact image exists, and propose the validated package and runtime changes together for review instead of pushing directly to main. (#107)
Scene (Release v3.6.0): Cancel pending lookups and hide obsolete results when query inputs change. (#39)
cli (Release v3.10.0): Compile a folder of .play files as one application so declarations resolve across files and diagnostics retain their source paths. (#168)
Components (Release v4.11.2): ColumnFilterMenu now returns focus to its own trigger button when the filter popover closes having dropped focus, for both Escape and outside-click dismissal, instead of depending on React Aria’s timing-sensitive automatic restore (#241)
Components (Release v4.11.2): Dismissing a filter menu by moving focus elsewhere — for example pressing another column’s filter trigger — leaves focus where the user put it, rather than pulling it back to the trigger whose menu closed (#241)
Components (Release v4.11.1): A filtered Dropdown now commits the option ArrowDown or ArrowUp made active: Enter reports it once, closes the list, and shows its label. Escape still dismisses without changing the selection (#239)
Components (Release v4.11.1): A Dropdown selection now closes its own overlay and settles its own filter text, instead of waiting for a value that may never come back or may resolve to none of the options (#239)
Components (Release v4.11.1): An unfiltered single-select Dropdown now shows the label of the option that was chosen, rather than keeping its placeholder, when the application does not bind the value back (#239)
Components (Release v4.10.4): ComboBox now offers every option when the list is opened by the trigger, by ArrowDown or on focus, instead of only the already-selected one; typing still narrows the list, and reopening after a selection shows everything again (#297)
Chronicle (Release v19.1.7): Subscribing an observer no longer waits for every failed partition to be handed to the jobs manager for recovery. An observer with hundreds of failed partitions previously exceeded the 30 second grain-call budget inside Subscribe, so the client timed out and the observer stayed unsubscribed - after a kernel restart this left reactors quarantined and projections disconnected until the next restart. Recovery now runs in a turn of the observer’s own once the subscription is established.
Components (Release v4.10.3): A disabled tag group now refuses to remove a tag with Delete or Backspace, matching the mouse behavior (#305)
Components (Release v4.10.2): The gap between tags in a TagGroup applies. (#293)
Components (Release v4.10.1): A single-selection ToggleGroup is one tab stop. The selected option carries it — or the first enabled option when the value matches none — and it follows the selection as it changes. Arrow-key movement and Space/Enter committing are unchanged. (#292)
Chronicle (Release v19.1.6): Projection subscribers now discard their silo-local cached pipeline when a projection definition changes, so events of a newly consumed event type are handled with the updated key resolvers instead of failing with Missing key resolver until the kernel restarts.
Stage (Release v3.21.1): The binding module imports each generated proxy from the slice folder that declares it, instead of from the project root where no proxy is written. Every import previously pointed at a file that does not exist. (#100)
Stage (Release v3.21.1): The generated frontend declares the types its own bundler configuration needs, so it type-checks and its build script runs. (#100)
Stage (Release v3.21.0): A generated application renders the screen it composed, instead of mounting an empty shell around a placeholder. (#100)
Stage (Release v3.21.0): The composed scene is written with the member names the Scene model declares, so it can be read at all. Serialized with .NET member names it parsed successfully and matched nothing, which would have rendered every screen empty without reporting an error.
AI (Release v7.0.0): AddDecisionEngineProvider and ReconfigureDecisionEngineProvider, and decision engines as a kind of configured AI provider. Choose the engine with the new commands instead
AI (Release v7.0.0): IDecisionProviderResolver and IDecisionProviderClient, replaced by IDecisionEngineResolver and IDecisionEngineClient
Arc.TypeScript (Arc for TypeScript 0.22.0 — grouped options): addChronicle, addMongoDB, addDrizzle and the free addCratis function; use withChronicle, withMongoDB, withDrizzle and builder.addCratis().
Arc.TypeScript (Arc for TypeScript 0.22.0 — grouped options): The flat prefix, segmentsToSkip, include*NameInRoute, correlationHeader, tenantHeader, resolveTenant, enableQueryMethod and maxBodyBytes options and identityDetailsSchema; use the grouped options above.
AI (Release v6.0.0): Cratis.AI.Providers.Resolving, whose ConfiguredAIProvider collided by name with the one in Cratis.AI.Providers.
AI (Release v6.0.0): The duplicate AIProviderPoolMember in Cratis.AI.Providers.Pools; the one in Pools.Listing is the single definition.
AI (Release v6.0.0): Cratis.AI.Agents.Identity is now Cratis.AI.Agents.Naming - a namespace called Identity shadowed Chronicle’s own Identity type for every consumer.
AI (Release v5.0.0): TierModelDefaults, the built-in table of per-vendor model names. It had already drifted from what the vendors serve - it named models that had been renamed, and one that never existed - and a tier pointing at a name the vendor does not serve fails silently, landing on whatever the harness falls back to.
AI (Release v4.0.0): ISecretProtector, ISecretRevealer and CratisAIBuilder.WithSecretProtection<T>().
Arc (Release v22.31.0): For commands and queries protected by a policy or authentication scheme, Arc checks the caller and the authorization requirements again immediately before the handler, query method or controller action runs, and denies the request if either changed after the policy verdict. (#2761)
Arc (Release v22.31.0): Missing or conflicting authorization configuration now denies the request with Unauthorized (403 at the HTTP endpoints) instead of running it or returning a server error, including when a custom command or query pipeline is registered. (#2761)
Chronicle (Release v19.7.6): The kernel development Compose file (Source/Kernel/Server/docker-compose.yml) now publishes MongoDB, PostgreSQL, SQL Server and the Aspire dashboard on 127.0.0.1 only, instead of on all network interfaces. These services use well-known development credentials (#4208)
Arc.TypeScript (Arc for TypeScript 0.24.1 — anonymous live queries over SSE): SSE hub control requests are accepted only from the caller that opened the connection: the same identity for authenticated callers, and additionally the same peer address for anonymous callers when the host provides one. Control requests must be JSON and pass the allowed-origins check, and each subscription still runs the query’s own authorization.
Arc.TypeScript (Arc for TypeScript 0.11.0 — authorization policies and identity): Observable queries restricted to specific authentication schemes are rejected at startup, because the shared WebSocket and SSE connections cannot honor per-query schemes.
Chronicle.TypeScript (Release v6.5.0): Reading a read model that holds personal data now fails when the data cannot be released, instead of returning the unreleased values.
Screenplay (Release v4.28.0): Attachment reads are confined to the model root. Paths are normalized and rejected if absolute, drive- or UNC-qualified, escaping the root with .., containing control characters, or naming a Windows device (CON, NUL, COM1, …). Links and reparse points on the file or any directory of its path are refused, and the resolved path is checked against the root again before reading.
Screenplay (Release v4.28.0): Only regular files are read. On Linux and macOS the file type is checked with lstat before opening, so a FIFO or device cannot block the MCP server or CLI; where the type cannot be verified, the attachment is refused with a warning. Sizes are checked before reading.
Screenplay (Release v4.28.0): Only a SHA-256 of an attachment’s content leaves the loader; contents are never shown, logged or persisted, and diagnostics name only the authored path. Link checks run before opening and after reading, but not as one atomic no-follow open, so a concurrent local writer could swa
AI (Release v4.0.0): An AI provider’s API key is no longer written to the causation chain in plain text. A command’s property values are recorded there before Handle runs, so protecting the value inside the handler never covered them — the key was stored in the clear, permanently, beside the event that protected it. AIProviderApiKey is now [NotAudited]. Anyone upgrading should treat keys configured through earlier versions as exposed in their own event log.
cli (Release v3.17.1): The screenplay MCP descriptor must be stdio, command cratis, with exactly screenplay mcp as arguments. Anything else is refused before any file is written, matching the rule the Pi bridge in Cratis/AI enforces.
cli (Release v3.17.1): cratis ai status flags a managed MCP entry whose launch command is not the allowed one.
Arc (Release v22.23.0): Policy and AuthenticationSchemes no longer silently fall back to authentication-only checks. Unknown, ambiguous, malformed, or unsupported requirements fail closed; applications using previously ignored settings must register valid policies and schemes before startup (#2736).
Arc (Release v22.23.0): Scheme-selected execution isolates the effective principal, tenant, and scoped services. Unsafe caller-supplied providers and identity-changing nested scheme calls are rejected rather than reusing services bound to another identity. Standalone Core does not support named authentication schemes (#2736).
AI (Release v3.3.0): A refused command tells the agent not to retry or work around it, and to report the exact command, its target server or context, and what it would change, so the user decides.
Components (Release v4.13.1): Every checkout in javascript-build.yml now sets persist-credentials: false. None of the build jobs push, so the token no longer stays in the local git config where later steps (dependency scripts, tests) could read it.
Arc (Release v22.21.0): [Authorize] and [AllowAnonymous] from Microsoft.AspNetCore.Authorization are enforced again on model-bound commands and read models when Arc is hosted on ASP.NET Core. Since v18.2.0 a model-bound artifact protected only with Microsoft’s [Authorize] was open to every caller — over HTTP, over hub subscriptions and through direct pipeline execution — because the evaluators meant to honour it read Arc’s same-named attributes instead (#2719)
Arc (Release v22.21.0): Every authorization attribute on a declaration now applies. Previously only the first one found was evaluated, so a second, stacked requirement — [Roles("Admin")] together with [Authorize(Roles = "Auditor")] — was silently dropped
Arc (Release v22.21.0): A declaration marked both [AllowAnonymous] and [Authorize]/[Roles] is always rejected as ambiguous. Previously it either threw or admitted anonymous callers depending on which evaluator was discovered first (#2714)
Screenplay (Release v4.15.0): Preserve restricted file access during model replacement, moves, and rollback; refuse recovery that would overwrite unexpected external edits.
Arc (Release v22.19.0): SSE subscribe and unsubscribe now verify that the caller owns the connection they name. The identity that opened the stream is captured once and compared on each control request; a mismatch returns 404, exactly as an unknown connection id does, so the endpoints never confirm another caller’s connection exists. Previously a caller holding another connection’s id could attach a subscription whose results were written into that caller’s stream, or cancel their subscriptions (#2713)
Arc (Release v22.27.2): <Arc basePath> is deprecated because it does not configure routing or API requests; its context value remains available for compatibility (#2593)
Screenplay (Release v4.33.0): ZeroOrOne and Many on a projection transition have no Chronicle meaning. An executable model that carries them, built in code or read from canonical bytes, reports warning PLAY0445; they will be removed in the next model version. Models compiled from .play sources never carry them.
Screenplay (Release v4.25.0): PLAY0176 is retired and no longer reported. Two identical reads lines used to give one PLAY0176 with the second line dropped; now both lines are kept and reported as PLAY0410. The DiagnosticCodes.DuplicateReads constant remains for compatibility.
