Cratis/Chronicle

Chronicle is an event-sourcing kernel and client SDK ecosystem that manages event streams, projections, and reactors across multiple storage backends. It provides comprehensive tooling for building event-driven applications, including strict data integrity constraints, GDPR-compliant PII encryption, and multi-tenant isolation. The system supports complex read model materialization through declarative and model-bound projections, reducers, and real-time change tracking, while offering robust clustering, performance benchmarking, and extensive documentation for developers.

146 changes.

This period focused on rebuilding the .NET client SDK with a new event model, gRPC communication, and robust multi-tenant support, while introducing comprehensive GDPR compliance and PII management features. The work also included significant architectural cleanup, such as removing legacy Node.js and desktop components, and establishing a new infrastructure for projections, reducers, and transactional event appending.

248 changes.

This period focused on expanding the Chronicle client ecosystem by introducing new SDKs for TypeScript, Kotlin, and Elixir, alongside significant enhancements to the .NET client including static analysis, security types, and event migration APIs. A major effort was dedicated to building a robust testing infrastructure, featuring in-process testing harnesses for reactors and read models, comprehensive integration tests across multiple storage backends, and extensive documentation for these new capabilities.

The AspNetCore client now includes a causation middleware that automatically captures request context for auditing purposes. When an HTTP request is processed, the middleware extracts details such as the route, HTTP method, host, protocol, scheme, query string, and route values, and adds them to the causation manager. It also includes the HTTP Origin and Referer headers when present. Requests to paths starting with '/.cratis' are ignored. This functionality is enabled by registering the middleware via the new 'AddCausation' extension method, which sets up the necessary services and startup filter.

Source/Clients/AspNetCore/Auditing · high confidence

The .NET client now includes a new SDK for registering external services, providing a fluent builder API to configure HTTP endpoints (with Basic, Bearer, or OAuth authentication and custom headers) and database endpoints (Microsoft SQL Server and PostgreSQL). Users can register these services via the \IExternalServices\ interface, which sends the configuration to the event store.

Source/Clients/DotNET/ExternalServices · high confidence

The .NET client now exposes an \IPatterns\ interface and implementation (\Patterns\) that allows applications to query behavior patterns mined from event history. This includes methods to retrieve patterns matching a specific context (\GetPatterns\), identify the most likely actions in a context (\GetUsualActions\), and determine what a scope usually does at a specific moment (\GetPatternsAt\). The API also supports listing all patterns for a scope (\GetPatternsForScope\) and discovering which scopes have established patterns (\GetScopes\). A \PatternsNotSupported\ exception is provided for event store implementations that do not support this feature.

Source/Clients/DotNET/Patterns · high confidence

The benchmark project now includes a full suite of performance tests for Chronicle, measuring the cost of single and batch event appends, projection and reducer throughput, reactor handling, projection replay, and passive versus materialized read model resolution. The infrastructure runs a Chronicle container via TestContainers with self-signed TLS certificates and scoped event stores to isolate benchmark cases.

Benchmarks/Chronicle.Benchmarks · high confidence

New documentation recipes have been added to the scenarios index to guide users through key Chronicle workflows. These include enforcing unique values via kernel constraints, evolving event shapes using type migrations without rewriting history, reacting to events with idempotent reactors, querying read models with strong or eventual consistency, rebuilding read models after projection changes, and testing slices in-process using the C\# testing library.

Documentation/scenarios · high confidence

The Documentation/benchmarks area now includes a new static web dashboard (index.html, data.js, benchmark-data.json) that visualizes performance metrics from BenchmarkDotNet. This change introduces a new UI component for users to view historical benchmark trends, download raw data, and see last-update timestamps, powered by the github-action-benchmark tool.

Documentation/benchmarks · high confidence

The .NET client now exposes the IEventStoreSubscriptions interface, allowing users to subscribe to events from a source event store's outbox, unsubscribe by ID, and retrieve all registered subscriptions via GetAll(). This includes a builder pattern (IEventStoreSubscriptionBuilder) to optionally filter specific event types before subscribing.

Source/Clients/DotNET/EventStoreSubscriptions · high confidence

New documentation pages have been added for Jobs and Webhooks, explaining how to inspect and control long-running Chronicle Kernel operations (such as replays and rebuilds) via the Jobs API, and how to configure server-side webhooks to push observed events to external HTTP endpoints. The entries include guides for listing, retrieving, and managing jobs, as well as registering and querying webhooks, with cross-references to related topics.

Documentation/jobs, Documentation/webhooks · high confidence

A new Python package, \cratis\_chronicle\_contracts\, has been added to provide generated gRPC messages and stubs from Chronicle's canonical \.proto\ files. This package serves as the wire-surface layer for the idiomatic \Cratis/Chronicle.Python\ client, exposing generated modules such as \eventtypes\_pb2\ and \protobuf\_net.bcl\_pb2\. The distribution includes build scripts (\generate.py\, \build\_package.py\) to create the package from proto sources, along with tests verifying that the event type contract and service stubs are correctly importable.

Source/Clients/Python · high confidence

A new documentation section at Documentation/statistics now provides an interactive dashboard for tracking test coverage metrics over time. The entry point is index.md, which embeds a coverage.html page powered by Chart.js. This page visualizes line coverage history for projects like Cratis.Chronicle and Cratis.Chronicle.Api, displays summary statistics (average coverage, project count, data points), allows users to toggle individual projects on and off, and includes a button to download the underlying coverage data as JSON. The data is sourced from coverage-data.js, which contains historical coverage entries linked to specific versions and commits.

Documentation/statistics · high confidence

The Seeding feature now includes generated TypeScript proxies for interacting with the seeding API. This adds the \AddSeedEntry\ command for creating individual seed entries, the \SeedEvents\ command for bulk seeding with global and namespaced entries, and the \GetGlobalSeedData\ and \GetNamespaceSeedData\ queries for retrieving seed data. These files provide the client-side interfaces and validation logic required to manage event store seeding.

Source/Workbench/Features/Seeding · high confidence

The Workbench now includes generated TypeScript classes and React hooks for monitoring connected clients. This adds a \ConnectedClientDetails\ read model and query classes (\AllConnectedClients\, \GetConnectedClients\, \ConnectedClientsForObserver\) that allow the UI to fetch and observe client connection data, including silo address, connection ID, version, and process details, via the \/api/clients/\ endpoints.

Source/Workbench/Features/Clients · high confidence

Added new documentation pages explaining the Chronicle Server event seeding capability, which allows providing predefined baseline or test data when the event store connects. The new content includes an overview of use cases (deterministic starting points, CI/bootstrap) and a detailed C\# guide covering implementation via \ICanSeedEvents\, handling repeated or rejected batches, namespace-scoped seeding, and development-only configurations.

Documentation/event-seeding · high confidence

The workbench now includes auto-generated TypeScript classes that expose the development tools API endpoints to the client. This adds a query to check if development tools are available on the server (\AreDevelopmentToolsAvailable\) and a command to reset the kernel state (\ResetKernelState\), allowing the UI to interact with these backend capabilities.

Source/Workbench/Features/DevelopmentTools · high confidence

The Schemas feature now includes generated TypeScript models for type formats, specifically the \TypeFormat\ read model (containing JSON type, CLR type name, and format string) and the \AllTypeFormats\ query class for retrieving all supported formats via the \/api/schemas/all-type-formats\ endpoint. These files are automatically generated by Cratis and are re-exported from the feature's index.

Source/Workbench/Features/Schemas · high confidence

The Workbench Server view now includes generated client-side queries to retrieve details for running server instances in the cluster. This adds the \ServerInstanceDetails\ read model (exposing ID, address, cluster status, CPU usage percentage, and memory usage in bytes) and two query classes: \GetServerInstances\ for one-time retrieval and \AllServerInstances\ for observing live CPU and memory snapshots. These are exported from the \Source/Workbench/Features/Servers\ module for use in the UI.

Source/Workbench/Features/Servers · high confidence

This change introduces a new UnitOfWorkMiddleware for the AspNetCore client that automatically manages transaction lifecycles within HTTP requests. The middleware begins a unit of work at the start of the request, commits it upon successful completion, and rolls back (disposes) it if an exception occurs. It also integrates with MVC by mapping constraint violations to ModelState errors and ensures a correlation ID is set if one is missing. The feature is wired into the application via a startup filter and a service collection extension (AddUnitOfWork) that registers the necessary dependencies.

Source/Clients/AspNetCore/Transactions · high confidence

The .NET client now includes a dedicated GDPR compliance layer that enables client-side management of Personally Identifiable Information (PII). Users can mark types or properties as PII using the new \[PII\] attribute, which is detected by the PIIMetadataProvider to enforce encryption rules (including support for record parameters and ConceptAs\<T\> types). The PIIManager interface and its implementation allow administrators to permanently erase encryption keys for a subject across all event stores in a namespace, rendering historical PII unreadable. To support lawful re-provisioning of data, a new AllowNewEncryptionKeyFor method authorizes the creation of a fresh encryption key for an erased subject, while specific exceptions (AllowNewEncryptionKeyNotSupported, PIINotSupportedOnEventSourceId) enforce constraints such as preventing PII marking on EventSourceId types.

Source/Clients/DotNET/Compliance/GDPR · high confidence

The .NET client now includes a local auditing system that tracks the origin and context of operations via a causation chain. This introduces a new \Causation\ record and a \CausationManager\ that maintains an immutable, last-in-first-out (LIFO) chain of causation events. Users can now use \BeginScope\ to create temporary audit contexts that automatically clean up when disposed, ensuring that distinct operations do not incorrectly appear causally linked. The system also provides client-side converters to serialize and deserialize these causation events to and from the server's contract models.

Source/Clients/DotNET/Auditing · high confidence

The .NET client now includes a local constraints engine that allows developers to define, scope, and register event constraints (such as unique constraints) directly from the client application. This change introduces a fluent builder API (IConstraintBuilder) for specifying constraint rules, including scoping options like PerEventSourceType and PerEventStreamId, and the ability to define removal events that release constraints. The client automatically discovers these constraints via providers, converts them into contract definitions, and registers them with the Chronicle server, ensuring that constraint metadata is synchronized between the client and the event store.

Source/Clients/DotNET/Events/Constraints · high confidence

The documentation for the Chronicle code-analysis rules has been expanded to include detailed reference pages for rules CHR0001 through CHR0037. These rules cover event type identification, reactor and reducer signature validation, projection and constraint purity, event store subscription boundaries, and compliance subject handling. The new entries provide rule descriptions, severity levels, violation examples, and explanations of why each rule exists to help developers catch configuration errors and anti-patterns at build time.

Documentation/code-analysis · high confidence

Added documentation for the \IProjections.Query()\ method, which allows running Projection Declaration Language (PDL) queries ad-hoc from the .NET client without defining a permanent read model. The new \adhoc-querying.mdx\ guide explains usage, explicit vs. inferred read models, error handling, and targeting different event sequences, while noting that this C\#-only API is intended for small, bounded event volumes and is not a replacement for registered projections.

Documentation/projections/projection-declaration-language · high confidence

Added comprehensive documentation for the declarative projection API, covering core concepts like AutoMap, explicit mappings, and initial values, as well as advanced features including hierarchical data with children and nested objects, cross-stream joins, composite keys, and event context usage. The docs also detail functional projections (count, increment, decrement), event sequence filtering, passive and non-rewindable modes, and constant keys for global aggregates, with client-specific coverage notes for C\#, TypeScript, Kotlin, Java, and Elixir.

Documentation/projections/declarative · high confidence

The Elixir SDK now includes a dedicated contracts module that embeds the canonical gRPC descriptor set (FileDescriptorSet) as a build artifact. This allows the client to verify protocol compatibility with the Chronicle kernel at connection time, ensuring that the client and server speak the same contract version without requiring runtime protobuf generation or external file lookups.

Source/Clients/Elixir/lib · high confidence

The Workbench now includes a comprehensive set of automatically generated TypeScript contracts (under Source/Workbench/Features/Contracts) covering Auditing, Captures, Events, External Services, Identities, Jobs, Observation, Primitives, Security, and Seeding. These generated types—such as EventContext, EventTypeRegistration, JobStatus, and ExternalServiceDefinition—provide the client-side data models and enums required to interact with the backend, ensuring type safety for event handling, job tracking, and service configuration.

Source/Workbench/Features/Contracts · high confidence

The Workbench now includes automatically generated TypeScript proxies for the Event Types feature, enabling developers to interact with event type definitions and registrations directly from the client. This addition introduces a read model (\EventTypeDetails\) and a suite of query hooks (\AllEventTypes\, \ObserveEventTypes\, \AllEventTypeGenerations\) for retrieving and monitoring event type data, alongside command proxies (\CreateEventType\, \RegisterEventTypes\, \RegisterSingleEventType\) for managing event type lifecycle operations.

Source/Workbench/Features/EventTypes · high confidence

The ExternalServices feature area now includes automatically generated TypeScript command and query proxies (AddExternalService, AddExternalServices, RemoveExternalService, RemoveExternalServices, GetExternalServices, ObserveExternalServices) and the ExternalService read model. These files provide the client-side interfaces for registering, removing, querying, and observing external services within an event store, exposing the corresponding API routes and validation rules to the workbench.

Source/Workbench/Features/ExternalServices · high confidence

The Recommendations feature now includes automatically generated TypeScript proxies (AllRecommendations, GetRecommendations, IgnoreRecommendation, PerformRecommendation, and RecommendationDetails) in the Workbench. These files provide the client-side interfaces for querying recommendation lists and executing ignore/perform commands, enabling the UI to interact with the backend API endpoints.

Source/Workbench/Features/Recommendations · high confidence

The Workbench now includes generated TypeScript proxies for the Sequence Queries feature, providing commands to save and delete queries and folders, as well as queries to retrieve all saved queries and folders. Additionally, generated concept enums for event constraints, job statuses, observation states, and sequence query scopes are now available in the Workbench, ensuring the frontend has access to the latest type definitions for these domain areas.

Source/Workbench/Features/Concepts · high confidence

The Workbench now includes automatically generated TypeScript proxies for the Identity feature, providing client-side support for querying and managing identities. This adds read models (IdentityDetails) and query hooks (AllIdentities, GetIdentities) for observing identity lists by event store and namespace, as well as a RenameIdentity command with validation for updating identity display names. These generated files enable the Workbench UI to interact with the Identity API using the Arc framework's query and command patterns.

Source/Workbench/Features/Identities · high confidence

The Workbench now includes automatically generated TypeScript files for managing Event Stores and Namespaces. This adds read models (EventStoreNames, NamespaceNames) and corresponding queries (AllEventStores, ObserveEventStores, AllNamespaces, ObserveNamespaces) that allow users to list and observe these entities, as well as commands (EnsureEventStore, EnsureNamespace) to create them. These generated components provide the necessary hooks (useQuery, useCommand, etc.) for the Workbench UI to interact with the backend API.

Source/Workbench/Features/EventStores · high confidence

The Workbench now includes automatically generated TypeScript files for job operations, providing client-side support for listing jobs (AllJobs), observing job changes in real-time (ObserveJobs), retrieving job steps (GetJobSteps), and controlling job lifecycles via commands to delete (DeleteJob), resume (ResumeJob), and stop (StopJob) jobs. These generated classes expose the necessary React hooks and query interfaces to interact with the corresponding backend API endpoints.

Source/Workbench/Features/Jobs · high confidence

Introduces a new Elixir package (\cratis\_chronicle\_contracts\) that provides generated protobuf message modules and gRPC client stubs for interacting with Chronicle services. The package includes a build script (\generate-protos.sh\) to generate these sources from the repository's protobuf definitions, along with standard Elixir project configuration files (\.formatter.exs\, \.gitignore\) and documentation. This serves as a foundational, non-idiomatic layer that idiomatic Elixir clients can build upon.

Source/Clients/Elixir · high confidence

The Kotlin client SDK is now available, providing the core infrastructure to connect to a Chronicle instance. This release introduces the ChronicleConnection class to manage gRPC channels, authentication (via API keys or OAuth2 client credentials), and TLS settings, along with a unified ChronicleServices object that exposes all available gRPC service stubs (such as EventStores, Namespaces, and EventSequences) for application use. It also includes the ChronicleConnectionString parser for configuring connection details and the ChronicleDescriptorSet to ensure protocol version compatibility between the client and the server.

Source/Clients/Kotlin/src · high confidence

The .NET client now exposes a new Webhooks API that allows users to register webhook observers and retrieve existing definitions. The \IWebhooks\ interface provides a \Register\ method that accepts a target URL and a builder (\IWebhookDefinitionBuilder\) for configuring the webhook, including setting the event sequence, specifying event types, adding custom headers, and configuring authorization (Basic Auth, Bearer Token, or OAuth). The builder also supports toggling replayability and active status. A \GetAll\ method is available to fetch all registered webhook definitions for the current event store. The implementation handles the conversion between internal domain models and the underlying gRPC contracts.

Source/Clients/DotNET/Webhooks · high confidence

Added a new benchmarking suite under the Benchmarks directory to measure Chronicle's performance, including single-node append operations and clustering scenarios. The infrastructure uses TestContainers to automatically manage Docker-based dependencies (Chronicle and MongoDB) for integration-style benchmarks, while an in-process Orleans cluster is used for clustering tests. The setup includes a run script, result merging logic, and CI integration to publish JSON results for visualization.

Benchmarks · high confidence

The .NET client now supports a Unit of Work pattern to group multiple event appends into a single transactional commit. This allows developers to stage events, enforce concurrency scopes, and commit them atomically via the new IUnitOfWork and IUnitOfWorkManager APIs. The implementation ensures ordered event batches, tracks concurrency and constraint violations, and provides OpenTelemetry tracing for commit and rollback operations, improving consistency and observability for multi-event client operations.

Source/Clients/DotNET/Transactions · high confidence

This change adds the foundational components for tracking and resolving compliance metadata, specifically for Personally Identifiable Information (PII). It introduces the \ComplianceDetailsAttribute\ to mark types or properties as PII, along with extension methods to retrieve these details from types, properties, and constructor parameters. A new \ComplianceMetadataResolver\ implementation and its interface (\IComplianceMetadataResolver\) provide a pluggable system for querying compliance metadata via \ICanProvideComplianceMetadataForType\ and \ICanProvideComplianceMetadataForProperty\ providers. The update also defines \ComplianceMetadata\ and \ComplianceMetadataType\ records (including a \PII\ constant) and adds implicit conversion support between \Subject\ and \EncryptionKeyIdentifier\ to facilitate seamless integration with existing identity and encryption models.

Source/Clients/DotNET/Compliance · high confidence

Added a new documentation section covering Chronicle's compliance features, including how to mark data as PII via property or concept annotations, how encryption and decryption work transparently in the kernel, and the mechanics of GDPR erasure through key deletion. The docs explain the encryption key lifecycle, the erasure fence mechanism that prevents key resurrection, and how PII lineage is handled in read models (projections vs reducers) with support for multi-subject ownership.

Documentation/compliance · high confidence

The event migration system now provides a type-safe API for defining property transformations between event type generations. Developers can use expression-based builders (e.g., \IEventMigrationPropertyBuilder\<TTarget, TSource\>\) to specify migrations like splitting, combining, renaming, setting defaults, and mapping values using C\# member accessors instead of raw JSON paths. The system automatically resolves these expressions to JSON property names using \JsonPropertyNameAttribute\ or the configured naming policy. Additionally, the \EventTypeMigration\<TUpgrade, TPrevious\>\ base class enforces that migrations bridge consecutive generations of the same event type, and value maps declared in \MapValues\ are automatically applied in both upcast and downcast directions.

Source/Clients/DotNET/Events/Migrations · high confidence

The .NET client now includes a dedicated Reducer subsystem that allows developers to define read models by implementing the IReducerFor\<TReadModel\> interface and decorating classes with the \[Reducer\] attribute. This change introduces the core interfaces (IReducer, IReducerHandler, IReducerInvoker) and implementations (ReducerHandler, ReducerInvoker) that handle event dispatch, instance activation via dependency injection, and state management. Users can now register reducers, discover them automatically, and retrieve their current state or replay events in-process using the IReducers service. The API also supports passive reducers that do not run actively on the server, observer notifications for state changes, and utilities for waiting on reducer states in integration tests.

Source/Clients/DotNET/Reducers · high confidence

The Keys area now exposes a new set of types for defining how events are keyed. This includes the \ContextKeyAttribute\ and \KeyAttribute\ for marking properties or methods, the \IKeyBuilder\<TEvent\>\ interface and \KeyBuilder\<TEvent\>\ implementation for specifying keys via property accessors, context values, or composite logic, and a \Key\<TEvent\>\ delegate to encapsulate key-building actions. These components provide the foundational API for controlling event key selection within the client.

Source/Clients/DotNET/Keys · high confidence

The ModelBound projection location introduces a new attribute-driven API for defining read models, including attributes such as FromEvent, ChildrenFrom, SetFrom, Count, Increment, Decrement, ClearWith, FromAll, FromEvery, GlobalFor, and EntersOn, along with the IModelBoundProjectionBuilder and IModelBoundProjections interfaces that discover and build ProjectionDefinitions from these attributes. This enables users to declare projection mappings, child collections, aggregations, and variant activation directly on model types via declarative attributes rather than fluent or manual wiring.

Source/Clients/DotNET/Projections/ModelBound · high confidence

The .NET client now exposes a formal API for interacting with jobs, allowing users to stop, resume, and delete jobs, as well as retrieve job details and progress. This includes new model classes for job status, steps, and progress, along with helper methods for waiting on job completion or state changes in integration tests.

Source/Clients/DotNET/Jobs · high confidence

The .NET EventSequences client now exposes a comprehensive API for appending events, featuring distinct result types (AppendResult and AppendManyResult) that report success, constraint violations, concurrency violations, and specific errors. The client supports batch appends via AppendMany, per-event metadata including tags, causation, and subject, and integrates with a concurrency scope strategy to validate event ordering and prevent race conditions. New types like EventsWithConcurrencyScopes allow grouping events with specific concurrency checks, while attributes like EventSequenceAttribute and EventLogAttribute enable explicit configuration of event sequences for observers. The client also provides OpenTelemetry tracing for append operations and supports waiting for observer completion after appends.

Source/Clients/DotNET/EventSequences · high confidence

The .NET client now exposes a dedicated Read Models API (IReadModels) that unifies access to materialized instances, change observation, and PII compliance. Users can retrieve paginated instances via IMaterializedReadModels, subscribe to real-time changes using IReadModelWatcher, and react to additions, modifications, or removals through the IReadModelReactor convention-based system. The API also includes a Release method to decrypt PII-annotated properties by deriving the subject from the instance itself, and handles JSON serialization edge cases like materializing empty collections as empty rather than null to match server-side semantics.

Source/Clients/DotNET/ReadModels · high confidence

The .NET client now includes a dedicated identity subsystem that allows applications to manage and track the identity of the actor causing state changes. This introduces an \Identity\ record (with support for delegation via \OnBehalfOf\ and deduplication) and a \BaseIdentityProvider\ that enables setting and retrieving the current user identity within the client context. Additionally, an \IIdentityManager\ implementation is provided, exposing a \Rename\ capability that allows updating the display name of an identity by its stable subject, with changes propagating to all associated events and read models.

Source/Clients/DotNET/Identities · high confidence

The .NET client now uses a structured builder pattern (IChronicleBuilder) to configure structural dependencies like identity providers, correlation ID accessors, and naming policies, replacing the previous flat options approach. It introduces an artifact activation system (ActivatedArtifact, ClientArtifactsActivator) that safely manages the lifecycle and disposal of discovered client components. Connection configuration is consolidated into ChronicleConnectionString and ChronicleOptions, supporting TLS settings, gRPC message size limits, and automatic artifact discovery. The client also includes OpenTelemetry tracing, claims-based namespace resolution, and retry logic for artifact registration.

Source/Clients/DotNET · high confidence

The AspNetCore client package now provides a dedicated integration layer for ASP.NET Core applications, replacing the previous generic \UseCratis\ extension with \AddCratisChronicle\ and \UseCratisChronicle\. This update introduces built-in support for multi-tenant scenarios by allowing event store namespaces to be resolved dynamically from HTTP headers (defaulting to \x-cratis-tenant-id\) or subdomains via \WithHttpHeaderNamespaceResolver\ and \WithSubdomainNamespaceResolver\. It also registers a \chronicle\ health check to monitor kernel connectivity status, ensuring applications can detect connection failures during startup or runtime.

Source/Clients/AspNetCore · high confidence

The Samples/AspNetCore directory now contains a complete, runnable ASP.NET Core application that demonstrates the Cratis Chronicle event-sourcing capabilities. This sample exposes HTTP endpoints to manage employee lifecycle events (hire, promote, move, email changes) and customer registration, utilizing read models to display current state. It includes a web UI for interactive testing and a reactor implementation that logs invocations to demonstrate how the kernel fans out events to application instances. The sample replaces the previous commented-out legacy code with a modern, integrated setup using the new Chronicle client libraries.

Samples/AspNetCore · high confidence

This release introduces the Cratis.Chronicle.Aspire package, providing first-class integration with .NET Aspire for provisioning and configuring the Chronicle server. Users can now add a Chronicle resource via AddCratisChronicle, which automatically selects a development image with embedded MongoDB for local testing or a production image when configured. The integration includes a dedicated AddCratisChronicleMongoDB helper that provisions a self-initializing single-node MongoDB replica set (required for Chronicle's change streams and transactions) with the correct directConnection settings. It also exposes builder extensions to wire up external storage backends (PostgreSQL, SQL Server, SQLite, and external MongoDB) and compliance encryption key storage via HashiCorp Vault or Azure Key Vault, along with TLS certificate mounting for secure endpoints.

Source/Clients/Aspire · high confidence

The Source/Tools area introduces two new utilities: the AssemblyFixer tool, which modifies assemblies to remove specific Orleans ApplicationPart attributes and add TypeManifestProviderAttribute entries, and the GrpcClients generator, which dynamically generates gRPC client implementations by reading and rewriting IL from contract assemblies. These tools support the broader gRPC code generation infrastructure by handling assembly metadata cleanup and client-side implementation generation.

Source/Tools · high confidence

A new Backoffice sample has been added to demonstrate end-to-end pattern detection. It generates a realistic, backdated history of internal company operations (accounts payable, procurement, HR, and payroll) across 26 weeks, featuring multiple distinct user roles with varied weekly routines. The sample includes the necessary domain concepts, events, and a generator that appends events with proper causation and correlation metadata, allowing users to explore how the pattern miner identifies behavioral routines and anomalies from the event context.

Samples/Backoffice · high confidence

Added comprehensive documentation for the Chronicle .NET client configuration, covering the \ChronicleOptions\ reference (including \EnableEventTypeGenerationValidation\, \SkipCompatibilityCheck\, and registration retries), camel-case naming policies for projections, gRPC message size limits, structural dependency injection, and TLS certificate validation settings.

Documentation/configuration · high confidence

Added a new Workbench documentation section that explains how to access the bundled local browser interface for inspecting Chronicle runtime state. The guide details starting the development Docker image, accessing the Workbench via the single Chronicle port (35000) over HTTPS, and logging in with default development credentials. It outlines the available inspection capabilities, including viewing connected clients, stores, namespaces, observer state, read models, and projection previews, while clarifying that this interface is for local evaluation only and does not authorize production mutations.

Documentation/workbench · high confidence

Added a new documentation section covering Chronicle connection strings, including server support, .NET client usage, and configuration. The docs detail the connection string format, authentication modes (client credentials, API key, and \auth=none\), load balancing strategies (least-connections, round-robin, random), DNS SRV lookup support, and TLS configuration options like \skipTlsValidation\. It also explains the wire-compatibility check and the \skipCompatibilityCheck\ escape hatch.

Documentation/connection-strings · high confidence

The DotNET.CodeAnalysis project introduces a comprehensive suite of Roslyn analyzers (CHR0001–CHR0051) that enforce correctness and safety in Chronicle event-driven code. These rules detect issues such as invalid event store combinations, missing \[EventType\] attributes, improper reactor signatures, and side effects in projections. The analysis also covers compliance and data integrity, flagging ambiguous \[ChildrenFrom\] mappings, unmapped read model properties, and unsafe handling of PII or mutable state in reducers and reactors.

Source/Clients/DotNET.CodeAnalysis · high confidence

A new three-part tutorial guides users through building an event-sourced library application, covering event creation, read model projections, and reactors. The documentation includes multi-language code snippets (C\#, Kotlin, Java, Elixir, TypeScript) and clarifies client-specific limitations, such as the absence of typed event source IDs in non-C\# clients and restricted reactor capabilities in Kotlin and Java.

Documentation/tutorial · high confidence

The Event Store section of the Workbench now includes dedicated pages for managing Event Types, Captures, Seed Data, External Services, and Observers, along with a new sidebar navigation structure. Users can view and edit event type schemas, manage capture definitions and view captured events, configure seed data by event source or type, and administer external service connections. The navigation has been reorganized to group these features under the Event Store context, with namespace-scoped pages for Observers, Failed Partitions, Recommendations, Jobs, and Identities, as well as system-level pages for Users, Applications, Connected Clients, and Servers.

Source/Workbench/Features/EventStore · high confidence

A new Kotlin client module has been added to Source/Clients/Kotlin, providing generated gRPC contracts and a Kotlin-friendly connection layer for Chronicle. The module includes a local generation workflow via a new generate-protos.sh script, which syncs protobuf definitions from Source/Kernel/Protobuf and uses Gradle (bootstrapped if necessary) to generate Kotlin coroutine stubs and message DSLs. The setup is configured with Gradle 8.13 and includes a README explaining the generation process and preferred usage of Kotlin coroutine stubs over Java-generated classes.

Source/Clients/Kotlin · high confidence

The analyzer library now includes a comprehensive suite of new diagnostics (CHR0001–CHR0051) that enforce safe usage of Chronicle's projection and constraint APIs. These analyzers detect ambiguous parent keys in \[ChildrenFrom\] collections, prevent AutoMap collisions with explicitly mapped properties, and warn when \[ChildrenFrom\] child collections map to nothing. They also enforce constraint hygiene by forbidding imperative code, side effects, and non-member-access lambdas in constraint definitions. Additionally, the analyzers flag cross-subject PII joins, unmapped child collections, and invalid EventStore+sequence combinations, helping developers catch data leakage and configuration errors at compile time.

Source/Clients/DotNET.CodeAnalysis/Analyzers · high confidence

The Samples/SimpleConsole directory now contains a complete interactive console application that demonstrates the Cratis Chronicle .NET client library. It introduces a full employee lifecycle domain (hire, promote, move, email) with model-bound and declarative projections, enforces uniqueness constraints (e.g., unique email), and showcases GDPR compliance by marking PII ConceptAs types (email, name, phone, address) with \[PII\] for automatic encryption. Sample data is generated on demand via the G key rather than at startup, and the app supports multiple storage backends (MongoDB, PostgreSQL, SQL Server, SQLite) and OpenTelemetry tracing.

Samples/SimpleConsole · high confidence

The TypeScript client library has been rebuilt using ts-proto and nice-grpc, introducing a modern Promise-based API for unary calls and AsyncIterable for server streaming. Users can now configure connections via structured connection strings that support OAuth 2.0 client credentials, API keys, and TLS settings, alongside a built-in development connection mode. The package ensures 64-bit integer safety by representing proto int64/uint64 values as JavaScript bigint and embeds the canonical descriptor set to validate contract compatibility with the Chronicle kernel at runtime.

Source/Clients/TypeScript · high confidence

Integration test fixtures now include extension methods to mutate the event log (revise specific events, redact single events or all events for a source with a reason) and to assert event log state (verify appended events and check next/tail sequence numbers). These utilities simplify writing integration tests that need to modify or verify event sequence data.

Source/Clients/XUnit.Integration/Events · high confidence

The Source/Clients/XUnit.Integration package introduces a comprehensive test fixture system for integration testing the Chronicle client and Orleans silo. It provides base fixtures (ChronicleFixture, ChronicleClientFixture) that manage Docker containers for MongoDB and the Chronicle service, supporting both in-process (silo co-hosted with test) and out-of-process (separate container) execution modes. Key components include ChronicleOrleansFixture for managing silo lifecycle, grain deactivation, and storage wiping between tests to ensure isolation, and ChronicleConnection for handling client connection lifecycle and keep-alive logic in the in-process scenario. The infrastructure uses a DelegatingClientArtifactsProvider to allow the shared silo to serve artifacts from the currently active test fixture, and a MutableServiceRegistry to update DI services between tests without tearing down the silo. This enables flexible, isolated integration tests for Chronicle's event sourcing, projections, and reactors.

Source/Clients/XUnit.Integration · high confidence

The Infrastructure layer now includes a new \Cratis.Chronicle.Changes\ namespace containing the core types for tracking and applying changes to read models. This introduces the \IChangeset\ interface and \Changeset\ implementation, which manage the lifecycle of incoming events, property mappings, and child operations (add/remove). It also provides \ObjectComparer\ for detecting property differences between states, \PropertyDifference\ and \PropertiesChanged\ records to represent specific changes, and specialized change types like \ChildAdded\, \ChildRemoved\, \Joined\, and \ResolvedJoin\. Additionally, extension methods in \ChangeCollectionPathExtensions\ and \UnindexedCollectionDifferences\ handle complex scenarios such as filtering conflicting collection updates and collapsing unindexed array changes into whole-collection replacements, ensuring that downstream sinks can apply changes without path conflicts.

Source/Infrastructure · high confidence

The documentation for hosting configuration has been restructured and expanded with new dedicated pages for authentication, clustering, compliance storage, client bootstrap, and health endpoints. Users can now find detailed guidance on bootstrapping initial admin credentials via configuration or environment variables, configuring multi-node Orleans clustering with role-based placement, and migrating encryption keys to dedicated compliance stores like HashiCorp Vault or Azure Key Vault. The docs also clarify the new dedicated health endpoint port, client bootstrap mechanisms, and best practices for configuration precedence and secret management.

Documentation/hosting/configuration · high confidence

Added two new documentation includes (\common.mdx\ and \mongodb.mdx\) to the get-started guide. The common section explains the core Chronicle workflow of defining events, appending them to an event log, creating read models via projections, and setting up reactors, while highlighting client-specific limitations for Kotlin, Java, and Elixir. The MongoDB section details the required convention pack configuration for the MongoDB client to correctly map Chronicle's document structure and clarifies how empty child collections are handled.

_Documentation/get-started/\includes · high confidence

Added a new documentation section covering Chronicle's event store subscription capabilities, including the outbox/inbox pattern, implicit subscriptions driven by \\[EventStore\]\ attributes, and explicit subscriptions managed via the \Subscribe()\ API. The new content also details how subject identity and encryption keys are preserved and propagated across event stores to support right-to-erasure compliance, including specific guidance on key lifecycle limits and erasure scope.

Documentation/subscriptions · high confidence

Added new contributing documentation for the Kernel, including guides on defining gRPC contracts using protobuf-net.Grpc (including streaming and OneOf types), implementing internal services, and using the new version patch system for handling upgrade migrations. The patch system documentation explains how patches are automatically discovered, applied in semantic version order, and tracked to ensure state consistency during upgrades.

Documentation/contributing/kernel · high confidence

Added a comprehensive set of documentation files under \Documentation/contributing/clients\ to guide developers in building and maintaining Chronicle client SDKs. This includes an index of client types (.NET, ASP.NET Core, Orleans, XUnit, API) and their dependency hierarchy, detailed instructions on the .NET client's runtime-only packaging and internalization strategy, and a value contract defining wire-format agreements for all clients. It also covers the workflow for extracting C\# gRPC contracts to \.proto\ files and generating TypeScript bindings, as well as guidelines for managing shared, multi-language code snippets via the \ChronicleClientTabs\ component.

Documentation/contributing/clients · high confidence

Added a new documentation section covering the Chronicle event type migration system, including an overview of the kernel-side migration architecture, multi-version storage, and a detailed C\# client guide for declaring event generations, defining migrators, and using operations like Split, Combine, RenamedFrom, DefaultValue, and MapValues. The documentation also explains generation validation rules enforced by the kernel to prevent silent data loss, including requirements for sequential generation chains and schema immutability, as well as how to relax validation in development environments.

Documentation/migrations · high confidence

Added comprehensive hosting documentation for Microsoft Aspire integration, including installation of the \Cratis.Chronicle.Aspire\ package, configuration for development and production modes, and guidance on wiring up TLS and encryption certificates, MongoDB replica sets, and other storage backends. The docs also cover connecting .NET clients, port usage, and image pinning.

Documentation/hosting · high confidence

Added a comprehensive 'Building a Client' documentation section that provides a structured guide for implementing new Chronicle clients. The section includes a high-level checklist, detailed pages on authentication (OAuth client-credentials flow and bearer token handling), clustering and connection lifecycle (including load-balancing strategies and wire-compatibility checks), connection string object models, and documentation standards for code snippets. It also clarifies the recommended architecture of separating generated contracts from the idiomatic client layer and explains how to handle empty collection results consistently.

Documentation/building-a-client · high confidence

The .NET client now includes a new event seeding system in the Cratis.Chronicle.Seeding namespace, allowing users to define seed data that applies globally by default or is scoped to specific event store namespaces via the new ForNamespace builder. This feature introduces a discover-and-register workflow where registered seeders (implementing ICanSeedEvents) are automatically activated and executed, and provides a CreateEventSeeding extension method to generate fresh seeding buffers for retrying corrected definitions without retaining previous failed batches.

Source/Clients/DotNET/Seeding · high confidence

The .NET client now exposes a new \EventSequences.Operations\ namespace containing a fluent builder API for event appends. Users can configure operations per event source using \ForEventSourceId\, attach causation metadata via \WithCausation\, and enforce optimistic concurrency using \WithConcurrencyScope\. The \EventSequenceOperations.Perform()\ method aggregates these configured operations into a single transactional append, ensuring that concurrency scopes are preserved across multiple events from the same source.

Source/Clients/DotNET/EventSequences/Operations · high confidence

The DotNET Captures client now provides a comprehensive set of builders and attributes to declaratively define data captures. Users can configure capture sources (API, Webhook, Message Topic) using the fluent \ICaptureBuilder\ interface, which supports polling intervals, routes, and authentication. Event appending logic is defined via \IAppendBuilder\, allowing conditions like property changes, transitions, or expressions. Data mapping is handled by \IMapBuilder\ with operations for renaming, templating, translating, and splitting fields. Additionally, a model-bound approach is introduced via attributes (e.g., \ApiCaptureAttribute\, \WhenPropertyChangedAttribute\, \MapFromAttribute\) to configure captures directly on classes and properties.

Source/Clients/DotNET/Captures · high confidence

The client-side projection API now exposes a comprehensive set of fluent builders for defining read model property mappings. This includes \IFromAllBuilder\ for applying operations like \Count\, \Increment\, and \Decrement\ across all events, and \IFromEveryBuilder\ for setting properties from any event type. The diff introduces specific builders for arithmetic operations (\AddBuilder\, \CountBuilder\, \DecrementBuilder\), relationship management (\IAddChildBuilder\, \IChildrenBuilder\, \INestedBuilder\), and key definition (\ICompositeKeyBuilder\, \IKeyBuilder\). These components allow users to construct complex projection definitions using a type-safe, expression-based fluent interface, replacing previous ad-hoc or less structured approaches.

Source/Clients/DotNET/Projections · high confidence

The benchmarking harness in Benchmarks/Chronicle.Benchmarks.Clustering has been expanded to support measuring Chronicle performance across different cluster topologies. A new parameterized in-process cluster harness (ClusterBenchmarkFixture) allows benchmarks to run against a single silo, two silos with shared roles, or two silos with split roles (separating event sequences from observers). This enables measuring the performance impact of cross-silo communication for append throughput, projection throughput, and projection replay scenarios.

Benchmarks/Chronicle.Benchmarks.Clustering · high confidence

The Workbench now includes generated TypeScript proxies for observing failed partitions (AllFailedPartitions, GetFailedPartitions) and managing observer states, including new commands to clear failed partition records (ClearFailedPartitions) and remove observers from quarantine (ClearObserverQuarantine). These additions provide the frontend with the necessary queries and commands to monitor partition health and resolve observer issues directly from the Workbench interface.

Source/Workbench/Features/Observation · high confidence

Added two new sample applications to demonstrate Chronicle's capabilities: a Composition sample that uses Aspire to orchestrate a local development environment with two Chronicle kernels, MongoDB, CoreDNS for SRV discovery, and a YARP reverse proxy to load-balance the embedded Workbench UIs with session affinity; and a WorkbenchHost sample that provides a standalone ASP.NET Core application hosting the Chronicle Workbench, demonstrating how to connect to multiple Chronicle servers via a connection string and load-balance gRPC connections.

Samples/Composition, Samples/WorkbenchHost · high confidence

The .NET client now introduces a set of strongly-typed security concepts in the Cratis.Chronicle.Security namespace to represent authentication details more explicitly. This includes Authority, Token, Username, Password, ClientId, and ClientSecret as distinct record types, alongside authorization models for BasicAuthorization, BearerTokenAuthorization, and OAuthAuthorization. These types provide a structured way to handle credentials and tokens, replacing raw strings with semantic types that support implicit conversion and empty-state handling.

Source/Clients/DotNET/Security · high confidence

Users can now enable distributed tracing for Chronicle client operations via OpenTelemetry. This change introduces a new \AddCratisChronicleInstrumentation\ extension method for \TracerProviderBuilder\ in the AspNetCore client library, which registers the \Cratis.Chronicle.Client\ activity source, allowing existing OpenTelemetry pipelines to capture and export traces generated by the .NET client.

Source/Clients/AspNetCore/OpenTelemetry, Source/Clients/DotNET/Diagnostics · high confidence

The Read Model Explorer feature now includes a set of automatically generated TypeScript files that provide client-side query capabilities and data models for inspecting read model state. Specifically, this adds the \AllSnapshotsForReadModel\ query to retrieve the history of snapshots for a read model, along with models for \ReadModelSnapshot\ and the \Event\ data that led to those snapshots. It also introduces \ReadModelInstances\ and \ReadModelOccurrences\ queries, paired with their respective \ReadModelInstance\ and \ReadModelOccurrence\ models, allowing users to explore the different instances and replay occurrences of a read model. These generated artifacts expose standard query hooks (such as \useQuery\ and \useSuspenseQuery\) and sorting/paging support for the Read Model Explorer UI.

Source/Workbench/Features/ReadModelExplorer · high confidence

Projections can now aggregate Personally Identifiable Information (PII) from different event sources into a single read model while maintaining strict GDPR compliance. The system ensures that each PII property is encrypted and associated with its originating subject, allowing for precise erasure: when a specific subject's data is deleted, only the PII belonging to that subject is removed from the read model, while other subjects' data remains intact and accessible.

_Integration/Client/for\_ReadModels/when\_a\_projection\_joins\_pii\_from\_another\subject · high confidence

The Workbench now includes generated command and query models for security operations (such as adding/removing users and applications, changing secrets and passwords) alongside a React-based authentication layer. This layer provides an AuthContext for session management, a ProtectedRoute component to guard internal pages, and a Login page that handles user sign-in, initial admin password setup, and forced password changes.

Source/Workbench/Features/Security · high confidence

The Source/Fundamentals directory has been removed, deleting the entire collection of core infrastructure files. This includes the Concept system (ConceptAs, ConceptFactory, ConceptMap, and related extensions), the DependencyInversion module (Autofac registration sources, convention modules, and provider delegates), the Execution context management (ExecutionContextManager, CorrelationId, and Orleans filters), and the GraphQL integration layer (SchemaRoute, GraphQLBuilderExtensions, and concept type converters).

Source/Fundamentals · high confidence

This change removes the \Guid\ utility class and \typeGuard\ type-checking function from the \Source/Node/Rudiments\ and \Source/Node/Types\ directories, along with their associated unit tests. Additionally, the entire \Source/Node/WebPack\ directory is deleted, removing the custom WebPack configuration files for both backend and frontend builds. This indicates a consolidation or migration away from these specific Node.js-side build and utility implementations.

Source/Node · high confidence

The Specifications project has removed its internal BDD (Behavior-Driven Development) infrastructure, including the \Cratis.BDD\ namespace with its \Specification\ base class, lifecycle method handling, and fluent assertion extensions (e.g., \ShouldContain\, \ShouldEqual\). Additionally, all existing test files under \Specifications/Fundamentals\ covering collections, concepts, and factories have been deleted. This change eliminates the custom testing framework and associated test coverage in this location, likely in favor of an external or centralized specification package as indicated by the commit history.

Specifications · high confidence

The Desktop application component has been removed from the codebase. This change deletes the Electron-based desktop app implementation, including the main process entry point, renderer UI components, build configurations, and associated assets, effectively discontinuing support for the standalone desktop client.

Source/Tooling · high confidence

The TypeScript proxies in Source/Workbench/Features/Sequences have been regenerated to reflect updated backend contracts. This includes new commands for appending events (Append, AppendMany, and the new AppendManyForEventSources for cross-event-source batches), a new query to list all event sequences (AllEventSequences), and a command to complete a stream (CompleteStream). The generated models now include updated structures for event context, causation, and concurrency scopes, ensuring the client-side API matches the current server-side definitions.

Source/Workbench/Features/Sequences · high confidence

The Kernel source has been reorganized into a new Core project, consolidating previously scattered functionality (such as Projections, Schemas, and Clients) into a single cohesive unit. This change includes migrating the communication layer from REST/GraphQL to gRPC services, upgrading the target framework to .NET 8, and modernizing the codebase for C\# 12. Users will benefit from a simplified project structure, improved performance via gRPC, and access to the latest .NET features, while the Workbench UI is now served directly from the Core assembly.

Source/Kernel · high confidence

This change introduces foundational repository infrastructure to standardize development and build processes. It adds a new SLNX solution file (Chronicle.slnx) to replace the legacy format, improving IDE and tooling compatibility. Build consistency is enhanced through new Directory.Build.targets and framework-specific package property files (Directory.Packages.NET8.props, Directory.Packages.NET9.props) that centralize dependency versions for .NET 8 and .NET 9 targets. Code analysis is standardized via a new .globalconfig file that explicitly sets diagnostic severities, and line endings are enforced with a new .gitattributes file. Additionally, a .dockerignore file is added to optimize Docker build contexts by excluding unnecessary artifacts like node\_modules and build outputs.

(repo-wide) · high confidence

The local \.pi\ directory has been restructured to replace its own content with symbolic links pointing to the shared \.cratis/ai\ directory. This change means that AI assistant capabilities—such as prompts for adding business rules, scaffolding features, code review, and writing documentation, as well as agents and skills—are no longer maintained locally but are instead adopted from the central Cratis AI contract. Users will now interact with the updated set of AI instructions and tools provided by the Cratis AI library.

.pi · high confidence

The ASP.NET Core client now includes an IdentityProvider that extracts user identity details (subject, name, username) from HTTP context claims, defaulting to the user identity name if specific claims are missing. If no identity information is found, it logs a trace message and returns a NotSet identity instead of failing. The implementation also adds structured logging to track when identity is set or not set.

Source/Clients/AspNetCore/Identities · high confidence

The project now uses a managed, versioned Cratis AI configuration system to standardize how AI coding assistants operate. A new \.cratis/ai.json\ file defines the supported AI harnesses (Claude, Codex, Copilot, Cursor, OpenCode, Pi), engineering and application profiles, and target languages. An \ai.manifest.json\ file manages the distribution of AI artifacts, including agent instruction files (backend/frontend developers, reviewers, coordinators, planners), hook scripts for quality gates and pattern scanning, and prompt templates. This change centralizes AI behavior rules and ensures consistent code generation and review standards across the development workflow.

.cratis · high confidence

The \.agents/skills\ directory is now a symbolic link pointing to \../.cratis/ai/skills\, redirecting agent skill definitions to the Cratis AI distribution. This change adopts the Cratis AI contract for skill management, ensuring that agent capabilities are provided through the managed Cratis AI setup rather than local definitions.

.agents · high confidence

The .claude directory now uses symbolic links to point to a shared AI configuration located in .cratis/ai. This change consolidates AI rules, agents, hooks, prompts, skills, and settings into a single source of truth, ensuring that updates to the central configuration are immediately reflected in the local Claude environment without duplicating files.

.claude · high confidence

The Source directory now uses a centralized Directory.Build.props file to enforce consistent build settings across all projects. This includes updating the project identity to 'Cratis Chronicle' (replacing the previous Cratis branding), setting the default target framework for test projects to .NET 10.0, and configuring Release builds to treat warnings as errors. The change also introduces global assembly metadata via GlobalAssemblyInfo.cs, adds standard NuGet package metadata (license, icon, readme), and includes common test dependencies (xUnit, NSubstitute, coverlet) for spec projects.

Source · high confidence

The Chronicle client connection layer has been rebuilt to support multiple authentication modes (Client Credentials, API Key, and None) via a new connection string format (chronicle://) and builder. The client now automatically injects authentication headers into gRPC calls and transparently refreshes tokens on 401 errors. TLS handling is more robust, allowing for custom certificate loading, pinning, and explicit validation skipping. The connection also supports multi-host configurations with DNS SRV resolution and configurable load-balancing strategies, while ensuring credentials are never logged in plain text.

Source/Clients/Connections · high confidence

The documentation site has been reorganized to improve discoverability and clarity. A new Architecture page explains the Chronicle kernel, protocol boundaries, and runtime scopes. A comprehensive guide on Constraints details how to enforce uniqueness and data integrity rules within the kernel. Namespace documentation has been added, covering multi-tenant isolation and client-side resolution strategies for .NET and ASP.NET Core. Additionally, new sections on Closing Streams, Event Evolution, and a migration guide from CRUD/EF Core have been introduced to help developers understand Chronicle's event-sourced model.

Documentation · high confidence

The \.cursor\ and \.opencode\ configuration directories now use symbolic links to point to the managed Cratis AI distribution located in \.cratis/ai\. This change centralizes the management of AI agents, skills, and command prompts (such as code-review, scaffold-feature, and add-business-rule) by redirecting both editors to a shared source, ensuring that updates to the Cratis AI harness are automatically reflected in both Cursor and OpenCode environments.

.cursor, .opencode · high confidence

The JSON schema generator has been replaced with a custom implementation that now supports geospatial types (Point, LineString, Polygon) with GeoJSON schema emission, preserves nullable markers for concept types, and recursively applies PII and compliance metadata to schema leaves. It also introduces a JsonSchemaTypeAttribute to override type representations in the schema, fixes crashes with non-primitive struct defaults, and ensures consistent naming policies.

Source/Clients/DotNET/Schemas · high confidence

Added comprehensive documentation for reducers, covering the event processing model (method discovery, sequential processing, and error handling), event sequence configuration via attributes, and filtering by event metadata (tags, source type, stream type). The new guides also explain passive reducers for on-demand state computation, external event store subscriptions, and reducer tagging for organization.

Documentation/reducers · high confidence

The integration test suite has been restructured into a dedicated project targeting .NET 10, replacing previous framework configurations. This change introduces a centralized build configuration that references the newly renamed Cratis.Chronicle.Testing package (previously Cratis.Chronicle.XUnit) and the Cratis.Chronicle.XUnit.Integration package, consolidating testing dependencies. Global usings are now defined to automatically include core testing namespaces, and the project is configured with specific NuGet audit settings and warning suppressions to streamline the test execution environment.

Integration · high confidence

The Patterns feature area now uses automatically generated TypeScript files (created by the Cratis tooling) to define the client-side contracts for behavior-pattern queries. New generated classes—AllPatternScopes, AllPatterns, MatchingPatterns, PatternsForScope, and UsualActions—provide the query definitions, sorting actions, and React hooks (useQuery, useSuspenseQuery, etc.) that the workbench uses to fetch pattern data from the backend. A new generated data model, BehaviorPatternDetails, represents the recurring pattern facets (including confidence, support, and recency-weighted strength), and a PatternScope model exposes scope identity details (id, name, userName) so that scope selectors and heatmaps can display the identity's display name. These generated artifacts replace hand-written contracts and ensure the client-side query layer stays in sync with the server-side pattern APIs.

Source/Workbench/Features/Patterns · high confidence

The Docker setup now includes robust entrypoint scripts that conditionally start an embedded MongoDB replica set only when the storage type is MongoDB, skipping it for SQL backends to save resources. Additionally, a new port diagnostic utility (\report-port-holder.sh\) is integrated into the entrypoints to identify which process is holding port 35000 if the Chronicle server fails to bind, preventing silent container exits and aiding in debugging port conflicts.

Docker · high confidence

The system now correctly handles legacy constraint definitions persisted before version 16.12, ensuring that single-event-type constraints are properly mapped and compared without causing registration failures. Additionally, the unique event type constraint mechanism now accurately enforces release cycles by querying the event sequence storage, allowing events only when the specific event source has released its previous constraint, thereby preventing duplicate event type usage within an open cycle.

Integration/Kernel/Events · high confidence

The .NET client now handles artifact registration failures more gracefully by introducing automatic retry logic with exponential backoff and jitter, preventing host startup crashes when the kernel is temporarily busy. Registration outcomes are now explicitly surfaced via a new \RegistrationOutcome\ model, allowing users to distinguish between successful registration, partial failures (where specific artifacts like projections failed to build), and total run failures, rather than leaving the state ambiguous. Additionally, a \WaitForRegistration\ helper is provided to synchronously wait for the registration process to complete, which is particularly useful for integration testing and ensuring the read side is fully up before proceeding.

Source/Clients/DotNET/Registrations · high confidence

The event seeding client now correctly preserves the order in which events were written by the seeder, preventing downstream state machines from receiving out-of-order history. Additionally, if a seed batch is rejected due to constraint violations (such as duplicate badges), the system no longer marks those events as seeded or takes the client offline; instead, it allows corrected seed definitions to be registered in a fresh buffer, ensuring that valid events within the batch are eventually persisted.

_Integration/Client/for\EventSeeding · high confidence

The integration test fixtures for the API have been updated to enforce secure communication. The \an\_http\_client\ class now configures an \HttpClient\ to connect to \https://localhost:35001\ using a specific PKCS12 certificate loaded from the fixture's configuration. It implements custom server certificate validation to ensure the connection matches the expected certificate, and automatically attaches a Bearer token obtained from the fixture to every request, ensuring that integration tests run against the API with proper TLS and authentication context.

Integration/Api/given · high confidence

The client library now defines a dedicated SinkTypeId record to uniquely identify sink types, including a None sentinel value. Additionally, the WellKnownSinkTypes class provides constants for InMemory, MongoDB, and SQL projection sinks, replacing the previous IExecutionContextManager interface which has been removed from this location.

Source/Clients/DotNET/Sinks · high confidence

The .NET client introduces a new event domain model centered on the \AppendedEvent\ record, which pairs an \EventContext\ with deserialized content. This change replaces previous event representations with a structured approach that includes typed identifiers (\EventSourceId\, \EventStreamId\, \EventStreamType\), observation states (\EventObservationState\), and redaction support (\EventRedacted\). A new \EventSerializer\ handles JSON serialization using \System.Text.Json\, supporting polymorphic event content via derived-type discriminators and custom converters for typed IDs. The update also adds attributes (\EventStoreAttribute\, \EventSourceTypeAttribute\, \EventStreamTypeAttribute\) to configure event store routing, concurrency scopes, and stream filtering for commands and observers, along with comprehensive converters to bridge between client types and contract/sequence representations.

Source/Clients/DotNET/Events · high confidence

A new documentation area under Documentation/read-models has been added, replacing older projection-focused content with a comprehensive guide to Chronicle's read model capabilities. The section introduces a Consistency Models page that explains the trade-offs between on-demand (strong), immediate (synchronous), and materialized (eventual) consistency. It provides detailed guides on retrieving read models, including getting single instances, fetching full collections, and inspecting historical snapshots. The documentation also covers materialized read model pagination for large datasets, indexing strategies using the \[Index\] attribute, and real-time change handling via watching and the new read model reactor pattern. Additional pages address specific behaviors such as empty child collection semantics, PII release mechanisms, and the rationale for the keyed-only query API.

Documentation/read-models · high confidence

This update introduces comprehensive documentation for event operations, including batch appends (\AppendMany\), event tagging, filtering reducers and reactors by tag, event source type, and event stream type, as well as event redaction and revision workflows. It also documents the \AppendOperations\ observable for real-time append notifications and the \WaitForCompletion\ mechanism. Concurrently, it clarifies that the first append into a concurrency scope is not checked by default to prevent race conditions on new partitions, with an opt-in \CheckFirstAppendIntoAScope\ feature available to enforce this check; this check is also skipped in mixed-version deployments to ensure backward compatibility.

Documentation/events · high confidence

The documentation has been restructured into a guided tour that walks users through running the Chronicle kernel locally and integrating it with their application. New guides cover three .NET hosting models—Console, Worker Service, and ASP.NET Core—detailing how to install the client packages, register Chronicle in the dependency-injection container, and append events. A central overview page explains the core event-sourcing loop (append, project, react) across all supported client SDKs, while a hosting-model selection page helps users choose the appropriate infrastructure setup, including local Docker, Aspire, or production-managed deployments.

Documentation/get-started · high confidence

The documentation site now includes a dedicated guide for upgrading from version 18 to 19, explaining that the change is a compile-time break in the .NET client where a method parameter changed from \bool\ to \bool?\ to support a new \skipCompatibilityCheck\ option. The guide clarifies that this requires a rebuild but does not affect the wire contract or other language clients. Additionally, a comprehensive history of all major version boundaries (from 6 to 19) has been added to help users understand the impact of upgrading across multiple versions, including notes on specific pitfalls like the broken 14.0.0 and 17.0.0 releases.

Documentation/upgrading · high confidence

The .NET client now provides a way to wait for append operations to be fully processed by downstream observers (Reactor, Reducer). The new \WaitForCompletion\ extension method blocks until observers have caught up or a timeout is reached, returning a result that includes any \FailedPartition\ details. This result exposes granular failure information, including the specific \FailureKind\ (Handling, Timeout, or Disconnected) and per-attempt stack traces, allowing developers to distinguish between system congestion and actual observer errors. Additionally, the \ObserverId\ type has been changed from a Guid to a string to support fully qualified type names, and the client now exposes observer lifecycle states such as Quarantined and Replaying.

Source/Clients/DotNET/Observation · high confidence

The .NET client now introduces a configurable option, CheckFirstAppendIntoAScope, which allows users to enforce a concurrency check on the very first event appended to a narrowed scope. By default, this check is disabled to maintain backward compatibility, meaning the first append into a new scope proceeds without verifying that no other events matching the scope's narrowing have appeared in the meantime. When enabled, the system validates that no matching events exist before allowing the append, rejecting it with a ConcurrencyViolation if a race condition is detected. This change also includes new types and builders (ConcurrencyScope, ConcurrencyScopeBuilder) to define these scopes and strategies, along with converters to serialize these expectations to the server.

Source/Clients/DotNET/EventSequences/Concurrency · high confidence

A placeholder certificate file (shared-dev.pfx) has been added to the client connections directory. The file contains dummy content ('NOT-A-CERTIFICATE') rather than a valid certificate, indicating it is intended for development or testing environments where a certificate file is required but a real one is not needed.

Source/Clients/Connections/Certs · medium confidence

The TypeScript client contracts in the Projection Editor feature have been regenerated to align with updated backend concepts. This update introduces new query classes for retrieving projections (AllProjections) and projections with their declarations (AllProjectionsWithDeclarations), and adds new command classes for generating declarative or model-bound code (GenerateDeclarativeCode, GenerateModelBoundCode). It also updates existing commands to support a new DraftReadModel definition for preview and save operations, and introduces a new command to save projections while automatically inferring the read model schema from event types (SaveProjectionWithInferredReadModel).

Source/Workbench/Features/ProjectionEditor · high confidence

Reactor handler methods now support richer dependency injection, allowing parameters beyond the event itself—such as EventContext, ReactorDelivery, read models, and arbitrary services—to be automatically resolved. The system introduces a new ReactorDelivery identity to track event deliveries for idempotency, a OnceOnly attribute to exclude specific handlers or entire reactors from replay, and a middleware pipeline (IReactorMiddleware) that runs before and after event invocation. Handler return values can now produce side effects (events) processed by extensible IReactorSideEffectHandler implementations, with failures reported via ReactorInvocationResult.

Source/Clients/DotNET/Reactors · high confidence

The side-effect processing pipeline in the .NET client has been refactored to use an extensible \IReactorSideEffectHandler\ pattern, allowing custom handlers to be registered via dependency injection. Reactors can now return \EventForEventSourceId\ objects to explicitly target specific event sources, stream types, and subjects, rather than relying solely on metadata resolved from the triggering event. The system also supports mixed collections of standard events and explicitly targeted events in a single atomic append operation, and provides detailed failure reporting including constraint violations and concurrency issues.

Source/Clients/DotNET/Reactors/SideEffects · high confidence

The projection expression types have been moved from the kernel's event store into the client's projection engine namespace, with \EventMetadata\ and \EventContext\ records replaced by expression classes (\EventSourceIdExpression\, \NoExpression\) that implement the new \IEventValueExpression\ interface. This change also introduces dedicated expression types for event content and context properties, and corrects the handling of null values: \ValueExpression.Null\ is now obsolete because it previously generated a literal string "null" instead of a clear operation; users should now use \NullExpression.Instance\ to properly clear a member back to no value.

Source/Clients/DotNET/Projections/Expressions · high confidence

The gRPC-based implementation for event observers has been removed from the .NET client. The files Observer.cs, ObserverInvoker.cs, and Observers.cs, which previously handled subscription and invocation via gRPC services and channels, have been deleted. This change eliminates the gRPC dependency for the observer functionality in this client, aligning with the decision to not use gRPC for the initial .NET client release.

Source/Clients/DotNET/Events/Observation · high confidence

The documentation for projections has been reorganized into a comprehensive, top-level section with improved discoverability. New pages cover the projection architecture (including the Screenplay compiler and Workbench integration), three distinct projection styles (Model-Bound, Declarative, and Reducers), and consistency models (Eventual vs. Immediate). The docs also clarify that projections do not filter events by metadata (tags/stream type), explaining how to combine them with reactors or reducers for that purpose. Additional content includes guides on tagging projections, the registration lifecycle (including retirement and replay policies), and a design document for nested projection objects.

Documentation/projections · high confidence

The .NET client hosting layer has been refactored to remove the previous microservice-oriented setup. The old \UseCratis\ extension methods and the \ClientBuilder\ class (which relied on gRPC and hardcoded localhost connections) have been removed. They are replaced by a simpler \AddCratisChronicle\ extension on \IHostBuilder\ that automatically registers necessary type converters, streamlining the initial client setup for users.

Source/Clients/DotNET/Hosting · high confidence

The Workbench can now be hosted as an embedded service within the main application via the \UseCratisChronicleWorkbench\ extension, exposing a configurable HTTP port (default 9876) and base path. This change introduces a dedicated \WebServer\ that manages the Kestrel lifecycle, configures the Arc identity and connection details, and serves the frontend static assets with correct path rewriting. It also adds a dark theme to the Swagger UI and ensures the API reuses the host application's gRPC connection rather than creating a separate one.

Source/Clients/Workbench · high confidence

A new extension method, TryGetPropertyPath, has been added to validate that expression-based property configurations are strictly limited to simple member-access chains (e.g., e =\> e.Property or e =\> e.Parent.Child). Unlike the existing GetPropertyPath method which silently returns empty or partial paths for unsupported shapes, this new method rejects complex expressions such as method calls, arithmetic, or constants, ensuring that only valid property paths are accepted during configuration.

Source/Clients/DotNET/Properties · high confidence

The event sequence append operations now return detailed result objects instead of throwing exceptions for rejections. New generated classes, AppendResult and AppendManyResult, expose success status, sequence numbers, and specific violation details including constraint violations (with type, name, and message) and concurrency violations (with expected vs. actual sequence numbers). This allows consumers to handle append failures programmatically by inspecting the result rather than catching exceptions.

Source/Workbench/Features/EventSequences, Source/Workbench/Features/Events · high confidence

The Workbench frontend has been upgraded to use PrimeReact 11 and @cratis/components 4, which introduces a shift to a 'styled-first' architecture where components no longer ship with default CSS. To maintain the existing visual appearance, the Workbench now includes a custom 'CratisPreset' and a vendored 'primereact-v10-palette' to map semantic tokens and restore legacy color variables. The styling stack has also been updated to use Tailwind CSS (via @tailwindcss/vite) for utility classes, while a new PrimeUI license key configuration (PRIMEUI\_LICENSE) is required to satisfy PrimeReact 11's commercial licensing checks. Additionally, the build and development environment has been standardized with Vite, Yarn 4, and Vitest.

Source/Workbench · high confidence

The Workbench's Captures feature area has been regenerated with new TypeScript read models and command/query classes. This includes read models for capture details and captured events, query classes to list and observe captures and their ingested events, and command classes to save, start, stop, delete, and validate capture declarations. These generated files provide the client-side interfaces for managing captures within the event store.

Source/Workbench/Features/Captures · high confidence

Integration tests for read models now explicitly wait for the projection engine to catch up and materialize instances before asserting results. New helper methods poll the underlying storage sink (checking for non-null values or total instance counts) with a timeout, replacing immediate reads that previously raced against the projection engine and caused intermittent failures or timeouts in out-of-process SQL scenarios.

_Integration/Client/for\ReadModels/given · high confidence

Resolved an issue where read models containing both Personally Identifiable Information (PII) and geospatial values would fail to project correctly. Previously, the compliance walk triggered by PII fields incorrectly treated GeoJSON members as lost schema properties, causing partition failures on the first event with a location. The fix ensures that geospatial data (such as venue coordinates and city names) is projected and stored intact while PII fields remain encrypted at rest.

_Integration/Client/for\_ReadModels/when\_a\_read\_model\_has\_pii\_beside\_a\_geospatial\value · high confidence

Added Elixir test helper configuration; Added EventScenario test harness specs for unique constraints and PII compliance; Added PII read model integration specs and guarded MongoDB document inspection; Added ReactorScenario testing infrastructure; Added base test fixture for ReactorInvoker specifications; Added comprehensive test coverage for ModelBound projection builder; Added comprehensive test coverage for ReactorScenario scenarios; Added comprehensive unit tests for EventSequence append operations; Added comprehensive unit tests for reactor side-effect handling and context value providers; Added documentation for testing Reactors with ReactorScenario; Added end-to-end integration tests for the Pattern Miner grain; Added in-process EventStore testing harness; Added integration test for concept collection projection persistence; Added integration test for implicit subscription inference with external inbox; Added integration tests for ChronicleClientFixture disposal and scope validation; Added integration tests for DNS SRV connection string resolution; Added integration tests for EventAppendCollection behavior; Added integration tests for MongoDB job storage; Added integration tests for ReadModelWatcher lifecycle and reconnection; Added integration tests for child object projection scenarios; Added integration tests for composed read model PII release behavior; Added integration tests for empty collection handling; Added integration tests for event type registration and retrieval; Added integration tests for job grain storage and reactor renaming patches; Added integration tests for large-scale event operations; Added integration tests for nested child projections; Added integration tests for nested projection scenarios; Added integration tests for projection read-model behavior; Added integration tests for unset optional read-model fields; Added integration tests for webhook registration and invocation; Added null causation manager for testing; Added regression test for PII child collection projection; Added regression test for multi-SetValue projection behavior; Added specs for EventSequence query methods; Added specs for ReactorInvoker invocation behavior; Added specs for the Aspire Chronicle and MongoDB provisioning helpers; Added test coverage for EventSequenceOperationExtensions; Added test coverage for EventStoreForTesting edge cases and compliance behavior; Added test coverage for GDPR compliance and PII management; Added test coverage for Reactor and Reducer type extensions; Added test coverage for Unique attribute constraint extensions; Added test coverage for event type migration scenarios; Added test coverage for identity provider, converter, and manager; Added test coverage for projection and read-model analyzers; Added test coverage for seeding large numbers of events in read models; Added test coverage for the .NET client's Patterns API; Added test fixture for ConstraintBuilder with owner context; Added test fixture for EventTypes specifications; Added test fixture for Reactor dependencies; Added test fixture for ReadModels registration with configured sink; Added test fixture for ReducerInvoker; Added test fixture for Reducers dependencies; Added test fixtures for EventSequence specifications; Added test fixtures for JsonSchemaGenerator with and without PII support; Added test fixtures for ReactorScenario specs; Added test fixtures for UniqueConstraintBuilder; Added test fixtures for constraint specification scenarios; Added test fixtures for event type generation and interface derivation; Added test for PII erasure reach with key-redirected projections; Added test for RegisterEventTypesRequest protobuf serialization; Added test for \[NoAutoMap\] exclusion on child properties; Added test for admin password status without system storage; Added test for backward compatibility of reactor middleware overloads; Added test for client instrumentation registration; Added test for default TLS certificate validation behavior; Added test for empty collection resolution in DefaultServiceProvider; Added test for nested property auto-map exclusion scoping; Added test for owned connection cancellation on client disposal; Added test for reducer fingerprint differentiation; Added test for schema constraint violation handling; Added test for watching non-existent Read Models; Added test infrastructure and specifications for event type handling; Added test infrastructure for ReadModels specifications; Added test infrastructure for reducer scenarios; Added test specifications for UnitOfWork event handling; Added test to verify consistency between client and kernel mirrored concepts; Added testing documentation for event append collection and testing boundaries; Added testing infrastructure for validating analyzers and code fixes; Added tests for AppendResultConverter concurrency check reporting; Added tests for AppendedEvent converter round-tripping and collection handling; Added tests for AuthenticationClientInterceptor retry logic; Added tests for CausationConverters and CausationManager auditing behavior; Added tests for Chronicle client service collection extensions; Added tests for Chronicle connection string builder and compatibility check policy; Added tests for Chronicle connection string parsing, builder extensions, and certificate validation; Added tests for ChronicleClient DI registration resilience and isolation; Added tests for ChronicleOptions default sink type ID binding; Added tests for ConcurrencyScope to Sequences Contract conversion; Added tests for ConcurrencyViolationConverter sequence number handling; Added tests for ConstraintViolation client conversion; Added tests for DefaultClientArtifactsProvider initialization and discovery behavior; Added tests for EventContextConverter subject handling; Added tests for EventForEventSourceId equality and comparison logic; Added tests for EventMigrationBuilder naming policies and nested path resolution; Added tests for EventRedacted JSON serialization round-tripping; Added tests for EventSeeding builder methods; Added tests for EventSerializer polymorphic serialization and lifetime scoping; Added tests for EventStore registration robustness and outcome reporting; Added tests for EventStore seeding buffer creation; Added tests for EventStreamId default sentinel behavior; Added tests for External Services client registration; Added tests for HTTP header and subdomain namespace resolution; Added tests for JsonSchemaGenerator behavior and edge cases; Added tests for JsonSchemaGenerator enum nullability and default value handling; Added tests for MaterializedReadModelDiffer and ReadModelReactor method discovery; Added tests for OAuth token provider caching, throttling, and refresh resilience; Added tests for PII schema generation with nested value objects and enums; Added tests for QueryResult and CommandResult serialization and mutation behavior; Added tests for Reactor and Reducer method resolution logic; Added tests for Reactor handler method validation and dependency injection; Added tests for ReactorInvoker handler method scenarios; Added tests for ReadModelScenario handling of unsubscribed events; Added tests for ReadModelWatcherManager watcher retrieval behavior; Added tests for ReducerInvoker creation validation; Added tests for ReducerInvoker with no initial state; Added tests for ReducerObservers and ReducerWatcher change notification; Added tests for Subject conversion from EventSourceId; Added tests for SubjectResolver edge cases; Added tests for TLS certificate validation policy resolution; Added tests for TypeUniverse behavior and container integration; Added tests for TypedEventSourceId conversions and creation; Added tests for UniqueConstraintBuilder error handling; Added tests for UniqueConstraintBuilder scenarios; Added tests for UniqueConstraintDefinition construction and contract conversion; Added tests for UniqueEventTypeConstraintDefinition removal event handling; Added tests for UnitOfWork batch enrollment and concurrency scope validation; Added tests for UnitOfWork disposal behavior; Added tests for changeset consolidation and child collection conflict handling; Added tests for compensation schema processing; Added tests for compliance release pass in materialized read models; Added tests for connection lifecycle event handling and subscription idempotency; Added tests for connection resilience, server address resolution, compatibility validation, and load balancing; Added tests for constraint builder provider with multiple builders; Added tests for constraint builder removal event declarations; Added tests for constraint builder scoping options; Added tests for contract serialization defaults and authorization handling; Added tests for embedded kernel package dependency closure; Added tests for event type registration and discovery logic; Added tests for explicit and resolved namespace handling in ChronicleClient; Added tests for expression accessor validation in property path extraction; Added tests for external event store subscription registration; Added tests for fluent projection builder clearing behavior; Added tests for in-process command pipeline consumer scope isolation; Added tests for null reducer return handling; Added tests for observation append completion and failed partition handling; Added tests for optimistic concurrency strategy and options; Added tests for per-append concurrency scope opt-in and strategy resolution; Added tests for protobuf round-tripping of empty optional members in AppendManyRequest; Added tests for reactor delivery identity and partition recovery idempotency; Added tests for reactor method argument resolution; Added tests for reactor registration error handling; Added tests for reactor replay functionality; Added tests for reactor side-effect append failure scenarios; Added tests for read model JSON serialization nullability handling; Added tests for read model handling of empty child collections; Added tests for read model projection of serialized event inputs; Added tests for read model property mapping edge cases; Added tests for read model registration scenarios; Added tests for read model release subject resolution and fallback behavior; Added tests for read model retrieval, compliance, and pagination; Added tests for read model snapshot retrieval by ID; Added tests for read-model paging scenarios; Added tests for reducer method detection with nullable reference types enabled; Added tests for registration backoff, outcome comparison, and wait extensions; Added tests for the Chronicle ASP.NET Core health check; Added tests for the type-safe event migration property builder; Added tests for unique constraint builder with multiple properties; Added tests for unique event type constraint builder scenarios; Added tests for variant projection mutual exclusion and shared handler behavior; Added unit test for webhook registration; Added unit tests for .NET Reducers client API; Added unit tests for AppendManyResult and AppendResult classes; Added unit tests for ConstraintBuilder validation; Added unit tests for EventMigrationPropertyBuilder operations; Added unit tests for EventSequence tail sequence number retrieval; Added unit tests for EventSequence.HasEventsFor; Added unit tests for EventSequenceOperations; Added unit tests for EventSourceIdJsonConverter and EventSourceIdJsonConverterFactory; Added unit tests for EventStoreSubscriptionBuilder and EventStoreSubscriptions; Added unit tests for EventsWithConcurrencyScopes construction validation; Added unit tests for Jobs client-side converters; Added unit tests for ReactorHandler event processing and identity management; Added unit tests for ReactorInvocationResult failure handling; Added unit tests for ReducerHandler event processing; Added unit tests for ReducerInvoker bulk and single-event invocation; Added unit tests for TagExtensions type inspection; Added unit tests for TransactionalEventSequence append operations; Added unit tests for UnitOfWork commit scenarios; Added unit tests for UnitOfWork rollback scenarios; Added unit tests for UnitOfWorkManager behavior; Added unit tests for WebhookDefinitionBuilder and WebhookDefinitionConverter; Added unit tests for constraint lookup and existence checks; Added unit tests for constraint registration and violation message resolution; Added unit tests for reducer validation and method detection; Added unit tests for the CausationMiddleware auditing behavior; Documentation for in-memory event testing utilities; Documentation for in-process ReadModelScenario testing utility; End-to-end verification of read model index creation in MongoDB; Expanded in-memory read model test harness coverage; Expanded integration test coverage for model-bound projection scenarios; Expanded test coverage for ReadModelScenario child projections; Expanded test coverage for ReadModelScenario read-model projection behaviors; Improved reliability for Event Store subscription integration tests; In-process testing infrastructure for Chronicle clients; Integration client test suite consolidation and expansion; Integration client tests for event sequence retrieval; Integration specs for passive projection read-model resolution; Integration test coverage for Reactor filtering, side-effects, and replay handling; Integration test for event sequence continuity after server restart; Integration test for multi-generation event migration and consumption; Integration test for retrieving event stores via API; Integration test scaffolding for Kernel JobsManager; Integration test setup for finding root key by child value; Integration tests added for PII encryption in read models; Integration tests for Event Store subscription behaviors consolidated into Client project; Integration tests for PDL nested projection compilation; Integration tests for PII event handling with geospatial data and subject-based encryption; Integration tests for Reactor Definitions storage operations; Integration tests for ReadModel instance retrieval moved to Client project; Integration tests for camel-case migration with custom naming policies; Integration tests for child projection joins and event ordering; Integration tests for clustering behavior with collapsing projections; Integration tests for enum value map migration in event sequences; Integration tests for event appending and unique constraints; Integration tests for event revision with replayable and non-replayable observers; Integration tests for event sequence redaction and observer replay behavior; Integration tests for event type migrations and default values; Integration tests for nested and non-existent child key lookups; Integration tests for nested object projection scenarios; Integration tests for paginated read model instance retrieval; Integration tests for projection joins with mixed key types and event ordering; Integration tests for projection property operations and removal scenarios; Integration tests for reactor-driven event appending and command execution; Integration tests for read model reactor event handling; Integration tests for reducers now cover deletion, filtering, PII, and geospatial scenarios; Integration tests for scaled-out client clustering behavior; Integration tests for seeded event projection scenarios; Integration tests for stream completion behavior; Integration tests for updating projection definitions; Integration tests now support multiple SQL storage backends; Integration tests verify PII encryption key erasure and cross-event-store propagation; Lightweight MongoDB integration test fixtures; New API integration test infrastructure with containerized kernel and TLS support; New in-process EventScenario testing harness with fluent assertions; New in-process read model testing harness; New integration test fixture for validating multi-silo clustering behavior; New integration test fixtures for projection event handling and read model mapping; New integration test read models for projections; Projection re-registration handles child collection removal and read model renaming; Read model subject property projection test added; Refactor projection integration test base class to close read-after-write race conditions; Refactor projection integration tests for stability and determinism; Tests for EventSequenceNumber sentinel values; Verify PII decryption in EventSequence integration tests.

This change updates dependencies across 97 manifests, including NuGet packages (e.g., Meziantou.Analyzer, Microsoft.AspNetCore.Authentication.JwtBearer, OpenTelemetry, System.Text.Json, Cratis.Arc, Cratis.Fundamentals, ApplicationModel, MongoDB.Driver, Swashbuckle.AspNetCore, Testcontainers, Orleans) and npm packages (e.g., @xmldom/xmldom, postcss, vite, rollup, flatted, braces, handlebars.net, lodash-es, micromatch, picomatch, undici, ws, ajv, tar, path-to-regexp, ts-deepmerge). The updates span patch, minor, and some major version bumps, reflecting routine maintenance and adoption of newer library versions.

(dependencies) · high confidence

Documentation for Chronicle Sinks added; Documentation for model-bound projections added; Initial documentation for Reactors; New Chronicle Concepts documentation area; Restructured constraint documentation into declarative and model-bound guides.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 42.

• Code Health 47
• Architecture 60
• Maturity 80
• Readiness 35
• Security 47
• Event-Driven 100
• Accessibility 42
• Performance 55

• 300 commits — 231 feature/other, 69 fixes

• (repo) — 81 commits
• Source/Kernel — 64 commits
• Source/Clients — 38 commits
• Documentation/statistics — 31 commits
• Source/Workbench — 22 commits
• (root) — 10 commits
• .github/workflows — 10 commits
• Documentation/upgrading — 9 commits
• Integration/Client — 7 commits
• .cratis/ai — 5 commits
• Documentation/client-snippets — 3 commits
• .ai/skills — 2 commits
• Documentation/troubleshooting — 2 commits
• Documentation/tutorial — 2 commits
• .github/scripts — 1 commit
• .github/timing-coupling-baseline.txt — 1 commit
• .pi/agents — 1 commit
• .pi/prompts — 1 commit
• Docker/Development — 1 commit
• Docker/entrypoint.sh — 1 commit

• fix: Add bulk select/ignore for Recommendations and fix Ignore not working
• fix: Fix Chronicle documentation structure and links
• fix: Fix Compatibility runtime closure in embedded test packages
• fix: Fix Kotlin sourcesJar implicit dependency on embedDescriptorSet
• fix: Fix Kotlin sourcesJar implicit-dependency failure on embedDescriptorSet
• fix: Fix Testing harness's Projections construction after #3983
• fix: Fix Workbench append/revise dialogs for string event content
• fix: Fix all-only observers never catching up on any event
• fix: Fix batch removal ordering during constraint validation
• fix: Fix cross-agent project concern links
• fix: Fix event append: protobuf-net cannot serialize JsonObject content
• fix: Fix in-process kernel command scope isolation
• fix: Fix initialized failure responses and array payload defaults
• fix: Fix permanent observer wedge in stranded catch-up recovery
• fix: Fix projections list scrolling in Workbench
• fix: Fix sidebar highlighting both General and namespace Seed Data items
• fix: Fix sidebar navigation collapsing to Recommendations after a System page visit
• fix: Fix unique event type constraint scope and batch claims
• fix: Fix zero-warning build in the new PatternScope spec
• fix: Merge branch 'consolidate/issue-3986': Bulk select/delete for Jobs, bulk select/ignore + fix for Recommendations (#3986)
• …and 280 more

• 17 HTTP endpoints (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Cratis/Chronicle was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.