tonyx/Sharpino
46.0
Weak · 9 November 2026
26.9k
lines of production code
F#
primary language
10
measurements over time
What this system is
Features
Add Sharpino.Sample.Client Elmish/Fable sample application
A new sample client project has been added to demonstrate an Elmish and Fable-based frontend interacting with the Sharpino backend via Fable Remoting. This sample includes the necessary configuration files (dotnet-tools, npm, gitignore), a Vite build setup, and F\# source code (Index.fs, Main.fs) that implements a basic Todo management UI using Feliz and Bulma, serving as a proof-of-concept for this specific frontend architecture.
Sharpino.Sample.Client · high confidence
Added Account and Counter domain models with event-sourcing infrastructure
The sample application now includes complete domain definitions for Account and Counter aggregates, each featuring state management (serialization/deserialization), command interfaces (Add/Remove Amount for Account; Increment/Decrement for Counter), and event definitions (AmountAdded/Removed, Incremented/Decremented). Additionally, RabbitMQ-based background consumers have been introduced for both aggregates to handle event streaming and state synchronization.
Sharpino.Sample.10/Models · high confidence
Added Balance aggregate model and event-driven consumer for sample application
The sample application now includes a new Balance aggregate that tracks account amounts and open courses, enforcing fees for course creation (100.0M) and cancellation (50.0M) with sufficient-funds validation. This change introduces the core domain model (Balance.fs), command handling (Commands.fs), event definitions (Events.fs), and a RabbitMQ-based background consumer (Consumer.fs) that listens for events, maintains local state, and supports fallback state retrieval.
Sharpino.Sample.9/models/Balance · high confidence
Added PostgreSQL functions for optimistic locking and event insertion
The database schema now includes a new \check\_last\_event\_id\_opt\_lock\ function that enforces optimistic locking by verifying the expected last event ID and acquiring a per-aggregate advisory lock to prevent concurrent write conflicts. Additionally, several helper functions (e.g., \insert\_01\_tags\_event\_and\_return\_id\, \insert\_md\_01\_tags\_event\_and\_return\_id\) have been added to insert events into specific tables while returning the generated ID, supporting both standard and metadata-augmented event storage.
Sharpino.Sample/db · high confidence
Added PostgreSQL schema with optimistic locking and advisory locks
The database schema now includes functions for inserting events with optimistic locking checks and per-aggregate advisory locks to prevent concurrent write conflicts. It also introduces specific table structures for aggregates and their events, supporting both standard and snapshot-based event insertion patterns.
Sharpino.Sample.3/db · high confidence
Added Row2 seat-booking domain model
The sample application now includes a second row (Row2) for seat booking, mirroring the existing Row1 implementation. This adds domain files defining the Row2 aggregate context, command handler, and event definitions, enabling users to book seats in the second row (seats 6–10) using the same Sharpino event-sourcing patterns.
Sharpino.Sample.2/Domain/Row2 · high confidence
Added Stadium domain model with row reference management
The sample application now includes a new Stadium aggregate root that manages row references. Users can add or remove row references by ID, with built-in validation to prevent duplicates or removal of non-existent rows. The model supports serialization/deserialization and defines specific storage and snapshotting configurations.
Sharpino.Sample.3/Stadium · high confidence
Added Todo domain model with state management and command handling
The sample application now includes a complete Todo domain model within the \Sharpino.Sample.25/Models\ directory. This introduces a \Todo\ entity with a defined state machine (Added, Started, Completed) that enforces temporal ordering for state transitions via \Activate\ and \Complete\ commands. The implementation includes corresponding \TodoEvents\ for event sourcing and \TodoCommands\ to handle user actions like activating, completing, or updating private data, along with JSON serialization support for persistence.
Sharpino.Sample.25/Models · high confidence
Added Transport Tycoon sample domain with RabbitMQ consumers
The sample application now includes a new 'Transport Tycoon' domain within the Site and Truck aggregates. This introduces domain models for Sites (managing trucks and connections) and Transporters (trucks with location and destination data), along with their respective commands and events. Additionally, background services (consumers) have been added for both aggregates to listen to RabbitMQ queues, process incoming messages, and manage local aggregate state.
Sharpino.Sample.8/Domain · high confidence
Added domain models for Todo and User aggregates
The Domain layer now includes the core entity definitions for the sample application. The Todo aggregate manages task states (Added, Started, Completed) with validation logic for activation and completion timestamps, while the User aggregate handles user profiles and the assignment/detachment of todos. Both aggregates are implemented with corresponding command handlers, event definitions, and JSON serialization support to facilitate persistence.
Sharpino.Sample.27/Domain · high confidence
Added generic TodosReport module for event aggregation
A new \TodosReport\ module has been introduced in the sample reports area, defining a generic \TodosEvents\<'TEvent\>\ record type. This type allows users to aggregate a list of events along with initialization and end times, providing methods to add single events or lists of events to the collection. The implementation uses a generic type parameter to support different event types, replacing a previously commented-out non-generic version.
Sharpino.Sample/reports · high confidence
Added reservation management and item tracking models with event sourcing support
The sample application now includes a new Reservation model that tracks item reservations (up to a maximum of 10 items) and supports closing specific items, alongside an Item model that manages name, description, and a reference counter. Both aggregates are implemented with event sourcing capabilities, including command handlers (Commands.fs), event definitions (Events.fs), and RabbitMQ-based background consumers (Consumer.fs) that process messages and maintain state via a fallback aggregate state retriever.
Sharpino.Sample.9/models/Reservation · high confidence
Added sample domain models for Materials, Products, and Work Orders
The sample application now includes complete domain models for managing materials, products, and work orders. The Material model supports adding and consuming inventory quantities, while the Product model serves as a placeholder for future implementation. The WorkOrder model introduces a state machine for tracking production progress, allowing orders to transition through Pending, Started, Completed, and Failed states, with validation ensuring working items are unique and initially pending.
Sharpino.Sample.16/Models · high confidence
Added script to generate optimistic locking migration scripts
A new Python script (add\_opt\_lock2.py) was added to the scratch directory. This script scans existing SQL migration files to identify specific aggregate event functions and automatically generates new migration files (20260629170000\_alter\_aggregates\_opt\_lock2.sql) that create corresponding 'opt\_lock2' versions of these functions. These new functions include optimistic locking checks for the main aggregate and any extra streams, ensuring data integrity during event insertion.
scratch · high confidence
Added seat booking domain logic for sample application
The sample application now includes a domain model for managing row seats, featuring logic to check availability, book specific seats, and retrieve available seat IDs. The booking process enforces business rules, such as preventing the isolation of a single free seat when other seats in the row are booked, and utilizes the Sharpino library's JSON serializer for state persistence.
Sharpino.Sample.2/Domain · high confidence
Added seat booking sample demonstrating multi-row transactions and optimistic concurrency
This change introduces Sharpino.Sample.2, a new example application that demonstrates event sourcing patterns for seat booking. It specifically illustrates how to handle transactions spanning multiple aggregates (rows) using the library's \runTwoCommands\ mechanism, ensuring atomicity across different event streams. Additionally, it showcases handling of optimistic concurrency and invariant preservation (such as preventing a single middle seat from being left free) through event filtering and optional pessimistic locking configurations defined in \appSettings.json\.
Sharpino.Sample.2 · high confidence
Azure Service Bus backplane support for distributed caching
Sharpino.Lib now supports Azure Service Bus as a backplane for the FusionCache distributed caching layer. This new capability allows multiple application instances to synchronize cache invalidations (entry sets and removals) in real-time via Azure Service Bus topics and subscriptions, ensuring cache consistency across a scaled-out deployment. The implementation includes a dedicated backplane module that manages the Service Bus client lifecycle, handles message fan-out to local cache instances, and integrates with the existing caching infrastructure.
Sharpino.Lib · high confidence
Database schema and optimistic locking for Goods, Cart, and GoodsContainer aggregates
The database now supports event-sourced aggregates for Goods, Carts, and GoodsContainers with dedicated event and snapshot tables, including indexes on aggregate IDs for performance. Optimistic locking is enforced via advisory locks to prevent concurrent write conflicts, and soft deletes are supported for snapshots. The schema also includes functions for inserting events with metadata and distance tracking from the latest snapshot.
Sharpino.Sample.7/shoppingCartWithSharpinoBinary/db · high confidence
Event-sourced database schema and optimistic locking for Course and Person aggregates
The database schema for the sample application now includes dedicated event-sourcing tables (events, snapshots, and aggregate-event mappings) for both Course and Person aggregates, along with helper functions to insert events. Optimistic locking has been implemented to prevent concurrent write conflicts: the system tracks the last event ID for each aggregate and validates it during writes. To ensure correctness under concurrent access, the locking mechanism uses PostgreSQL advisory locks to serialize writes to the same aggregate, and supports checking constraints across multiple streams simultaneously.
Sharpino.Sample.14/db · high confidence
Event-sourced domain models and database schema for Materials, Products, and Work Orders
This sample application now includes the core domain models and their corresponding PostgreSQL persistence layer. The F\# code defines the Material, Product, and WorkOrder aggregates, including their state transitions (such as consuming materials or completing work orders), event definitions, and command handlers. The database schema provides the necessary tables for event streams and snapshots for each aggregate, along with stored procedures to handle event insertion. The schema also implements optimistic locking to prevent concurrent write conflicts, enhanced by advisory locks to ensure per-aggregate serialization under concurrent access.
Sharpino.Sample.17/db · high confidence
Initial repository structure and library documentation
The repository is initialized with the core Sharpino event sourcing library, including the solution file, project definitions, and source code. This release introduces the library's foundational components: an in-memory event store for testing, a PostgreSQL-based event store, and a caching layer for aggregate states. It also adds comprehensive documentation (README, CONTRIBUTING, Code of Conduct, License) and sample projects to demonstrate usage, including support for RabbitMQ message integration and soft delete functionality.
(repo-wide) · high confidence
Interactive demo for multi-node L1/L2 cache synchronization
Sharpino.Sample.22 introduces an interactive command-line application that demonstrates the framework's L1 (in-memory) and L2 (SQL) caching layers working together with Azure Service Bus for cross-instance invalidation. The sample configures a dual-node setup where running the application in two separate terminals allows users to verify that updates made in one instance (e.g., renaming a todo) are automatically reflected in the other via L1 cache eviction messages. It relies on a Docker Compose environment providing PostgreSQL for the event store, SQL Server for the L2 cache, and a Service Bus emulator for the notification backplane.
Sharpino.Sample.22 · high confidence
Introduce Goods aggregate with binary serialization and RabbitMQ consumer
The Goods sample now includes a complete event-sourced aggregate for managing product items, featuring a \Good\ entity with price and quantity validation, corresponding domain events (\PriceChanged\, \QuantityAdded\, \QuantityRemoved\), and command handlers that support undo operations. These components are configured to use binary serialization for state and events, and a new \GoodConsumer\ background service has been added to listen for these events from a RabbitMQ queue, enabling the Goods module to process updates via the message broker.
Sharpino.Sample.7/shoppingCartWithSharpinoBinary/Goods · high confidence
Introduce Goods domain model with event sourcing and RabbitMQ integration
The Goods sample now implements a complete event-sourced aggregate for managing product items, including price changes and quantity adjustments. The domain logic is defined in Good.fs with validation, while Commands.fs handles state transitions and implements undo capabilities for price and quantity operations. Events.fs defines the domain events (PriceChanged, QuantityAdded, QuantityRemoved) with serialization support. Consumer.fs integrates the sample with RabbitMQ, providing a background service that consumes messages and maintains local aggregate state via a concurrent dictionary, with fallback state retrieval support.
Sharpino.Sample.7/shoppingCartWithSharpino/Goods · high confidence
Introduces Student aggregate model with enrollment logic and event sourcing components
Adds the core Student domain model, including the Student entity with course enrollment/unenrollment capabilities, command definitions for Enroll and Unenroll actions, event definitions for EnrolledCourse and UnenrolledCourse, and a RabbitMQ-based consumer that manages student state using an in-memory cache.
Sharpino.Sample.11/Models/Student · high confidence
Introduces Teacher aggregate model with course management and event sourcing infrastructure
The Teacher sample now includes a complete event-sourced domain model for managing a teacher's courses. This adds a Teacher aggregate that enforces a maximum of five courses, along with corresponding CourseAdded and CourseRemoved events. The implementation includes command handlers for adding and removing courses, a RabbitMQ-based consumer for processing events, and serialization support, establishing the foundational structure for this specific sample scenario.
Sharpino.Sample.9/models/Teacher · high confidence
Introduces shopping cart domain logic with event sourcing and RabbitMQ integration
The sample application now includes a complete shopping cart implementation within the Cart module. This adds the core domain model (Cart aggregate) supporting operations to add, remove, and query goods, along with corresponding domain events (GoodAdded, GoodRemoved, GoodsAdded). It introduces command handling with undo capabilities for adding and removing items, and integrates a RabbitMQ-based consumer (CartConsumer) that listens for events, maintains local state in a concurrent dictionary, and allows fallback state retrieval. Serialization and deserialization are handled via jsonPSerializer, and the aggregate is configured with a specific storage name, version, and snapshot interval.
Sharpino.Sample.7/shoppingCartWithSharpino/Cart · high confidence
Introduction of Sharpino.Lib.Core with configurable event evolution behavior
The new Sharpino.Lib.Core library introduces the foundational types for the event sourcing framework, including definitions for Events, Commands, and Undoers. It provides the core 'evolve' function to compute aggregate state from events, featuring a new \evolveSkippingErrors\ mode (controlled by the \EVOLVE\_SKIPS\_ERRORS\ compile-time flag) that allows the system to gracefully skip invalid events and recover state, alongside the existing unforgiving error mode. The library also includes utility modules for serialization interfaces, result handling, and testing helpers.
Sharpino.Lib.Core · high confidence
New Course aggregate model with student/teacher management and RabbitMQ consumer
The sample application now includes a complete Course domain model featuring commands to add or remove students and teachers, along with corresponding events (StudentAdded, StudentRemoved, TeacherAdded). The Course aggregate enforces constraints such as a maximum number of teachers (3) and a configurable maximum number of students. It also supports data migration from an older 'Curse001' schema. A new background service (CourseConsumer) has been added to consume events from a RabbitMQ queue, maintaining local state and supporting fallback state retrieval for consistency.
Sharpino.Sample.9/models/Course · high confidence
New Ingredients domain model with event-sourced commands and RabbitMQ consumer
The Ingredients sample now implements a full event-sourced domain for managing ingredients, including types and measures. It introduces an \Ingredient\ aggregate with methods to add or remove ingredient and measure types, paired with corresponding \IngredientEvents\. Commands are handled via an \AggregateCommand\ interface that validates state changes and produces events. A new \IngredientConsumer\ background service connects to RabbitMQ to consume these events, maintaining local state in a concurrent dictionary and supporting fallback state retrieval.
Sharpino.Sample.6/Ingredients · high confidence
New SeatBooking service for managing theater seating and reservations
Added a new SeatBooking service in the API layer that provides methods for managing theater rows, seats, bookings, and vouchers. This service exposes operations to add and retrieve rows, add and retrieve vouchers, add and remove seats from rows, and create and assign bookings, utilizing the underlying event store and message senders to coordinate these domain actions.
Sharpino.Sample.FormerlySaga/Api · high confidence
New Student domain model with course management and event sourcing support
Added a new Student aggregate model for the sample application, including the core entity with course add/remove logic, command definitions for adding and removing courses, event definitions for course changes, and a RabbitMQ-based consumer for processing events and maintaining state.
Sharpino.Sample.9/models/Student · high confidence
New Student2 aggregate model and event-driven consumer
This change introduces a new 'Student2' domain model within the sample application, featuring a distinct aggregate structure with course enrollment limits and annotation tracking. It includes the corresponding command handlers (Enroll, Unenroll, AddAnnotation) and event definitions (EnrolledCourse, UnenrolledCourse, AnnotationAdded) to manage state transitions. Additionally, a new background consumer service is added to process these events via RabbitMQ, utilizing an in-memory cache for state management and a fallback retriever mechanism.
Sharpino.Sample.11/Models/Student2 · high confidence
New domain models and event-sourced consumers for theater seat management
The sample application now includes a complete event-sourced domain for managing theater seating, introducing new aggregates for Theaters, Bookings, Rows, and Vouchers. Each aggregate is paired with specific commands (such as assigning seats, adding rows, or consuming vouchers) and events, along with background consumers that listen to RabbitMQ queues to maintain in-memory state and handle concurrency via fallback retrievers. This adds the underlying infrastructure for tracking seat availability and booking assignments within the sample saga.
Sharpino.Sample.FormerlySaga/Domain · high confidence
New domain models for Course, Student, and Enrollment aggregates
The sample application now includes domain models for managing courses, students, and enrollments. This change introduces the Course aggregate (supporting name renaming), the Student aggregate (supporting name renaming), and the Enrollment aggregate (supporting adding new enrollments). Each model is implemented with corresponding commands, events, and serialization logic to persist state changes.
Sharpino.Sample.15/Models · high confidence
New sample application demonstrating cross-aggregate event sourcing with soft deletes and async support
Sharpino.Sample.9 introduces a comprehensive Course Management System example that showcases advanced event sourcing patterns, including soft deletes with reference counting, multi-aggregate command execution, and conditional cross-aggregate constraints. The sample provides both synchronous and asynchronous manager implementations (CourseManager, CourseManagerAsync, ItemManager) to handle operations like enrolling students, assigning teachers with constraint checks, and managing financial balances. It supports multiple storage backends (PostgreSQL and in-memory) and optional RabbitMQ integration for event consumption, complete with a full test suite validating these complex domain interactions.
Sharpino.Sample.9 · high confidence
New sample application demonstrating event sourcing with GDPR data replacement
Sharpino.Sample.25 introduces a complete sample application that demonstrates the Sharpino event sourcing framework, including a Todo aggregate with state management and a new capability to replace sensitive data events (GDPR compliance) via \GDPRReplaceEventsByPredicate\. The sample includes a PostgreSQL-backed event store setup via Docker Compose, an in-memory storage fallback, and comprehensive tests covering todo creation, retrieval, private data updates, and the new sensible event replacement feature. Also in this area: Sample projects updated to use newer database versions and simplified setup.
Sharpino.Sample.25 · high confidence
New sample application demonstrating event-sourced Todo, Tag, and Category management
The Sharpino.Sample project has been introduced as a new reference implementation for building event-sourced applications in F\#. It provides a complete web service (via Fable.Remoting/Giraffe) for managing Todos, Tags, and Categories, backed by an event store. The sample supports both in-memory and PostgreSQL storage backends, includes logic for state viewers and command execution, and demonstrates domain modeling with contexts and events. It also includes serialization utilities and configuration via appSettings.json, serving as a practical starting point for users adopting the Sharpino library.
Sharpino.Sample · high confidence
New sample application demonstrating multi-command execution and RabbitMQ integration
This entry introduces the Sharpino.Sample.10 project, a new sample application that showcases advanced command handling capabilities. The sample provides a CounterApi for managing counters and accounts, featuring methods to create, retrieve, and increment single or multiple aggregates. It specifically demonstrates the ability to run multiple commands across different aggregate types (counters and accounts) in a single transactional batch using pre-executed commands. The sample also includes integration with RabbitMQ for event publishing and consumption, configurable via appSettings.json, and is supported by a comprehensive test suite in Tests.fs that validates both synchronous and asynchronous multi-command scenarios.
Sharpino.Sample.10 · high confidence
New sample application for event sourcing with FSharp.SystemTextJson
Added Sharpino.Sample.11, a new example project demonstrating an event-sourced Course and Student management system. This sample replaces the previous FsPickler serialization with FSharp.SystemTextJson and includes a CourseManager and StudentManager for handling aggregate commands, bulk loading tests, and optional RabbitMQ integration for distributed state viewing via background consumers.
Sharpino.Sample.11 · high confidence
New sample demonstrating coordinated command execution for material and work order management
Added Sharpino.Sample.16, a new example project that emulates a Process Manager/Saga pattern using coordinated commands rather than event-driven command triggering. The sample introduces a MaterialManager that manages Materials, Products, and WorkOrders, ensuring atomic execution of related operations (such as consuming materials when creating a work order) via the \CommandHandler.runInitAndNAggregateCommandsMd\ API. It includes domain models for tracking quantities, a PostgreSQL-backed event store setup via Docker Compose, and a comprehensive test suite verifying material consumption, work order lifecycle transitions, and failure handling with material restoration.
Sharpino.Sample.16 · high confidence
New sample demonstrating event-driven command compensation
Sharpino.Sample.17 introduces a proof-of-concept implementation where events trigger subsequent commands, effectively acting as a process manager. Unlike previous examples that execute compensating actions synchronously, this sample uses a message sender to react to stored events (such as a work order failure) and automatically invoke new commands (like restoring material quantities). The sample includes the necessary domain models, a material manager for orchestrating these interactions, and tests verifying the end-to-end flow of material consumption and event-driven restoration.
Sharpino.Sample.17 · high confidence
New sample domain for managing tags
The sample application now includes a new domain area for managing tags, mirroring the existing categories implementation. This adds the ability to add, remove, and retrieve tags within the sample, including support for undoing tag additions via a specific undoer logic in the command handler.
Sharpino.Sample/Domain/Tags · high confidence
New shopping cart sample application with event sourcing
Added a new sample application (Sharpino.Sample.7) demonstrating a multi-aggregate shopping cart system built with Sharpino. The sample includes domain models for Goods, Carts, and a GoodsContainer, along with commands, events, and a Supermarket service that coordinates operations across these aggregates. It supports both in-memory and PostgreSQL event stores, includes comprehensive tests using Expecto, and features optional RabbitMQ integration for event publishing and consumption.
Sharpino.Sample.7/shoppingCartWithSharpino · high confidence
New shopping cart sample with binary serialization and RabbitMQ support
Added a new sample application (Sharpino.Sample.7) demonstrating a shopping cart system built with Sharpino. This sample introduces binary serialization for events and state (using \binarySerializer\ in \GoodsContainer\, \Good\, and \Cart\ aggregates) and integrates RabbitMQ for event publishing/consumption (via \RabbitMqReceiver\, \GoodConsumer\, and \CartConsumer\ in tests). It includes full aggregate definitions (\GoodsContainer\, \Good\, \Cart\), command handling with undo support (\GoodsContainerCommands\), and a \SuperMarket\ facade for business logic, all configured via \appSettings.json\ and tested with Expecto.
Sharpino.Sample.7/shoppingCartWithSharpinoBinary · high confidence
New transport-tycoon sample application
Adds a new sample project (Sharpino.Sample.8) that demonstrates the transport-tycoon domain exercise. It includes domain definitions (sites, connections, trucks), a command handler for managing sites and trucks, and configuration files for the event store and logging.
Sharpino.Sample.8 · high confidence
Optimistic locking and multi-aggregate event sourcing for Todo and User domains
The sample application now supports event-sourced aggregates for both Todo and User entities, including domain models, command/event handlers, and the corresponding PostgreSQL schema. New database migrations create the \events\_01\_Todo\, \snapshots\_01\_Todo\, \aggregate\_events\_01\_Todo\ tables (and identical structures for User) to store event streams and snapshots. Optimistic locking is enforced via database functions that verify the expected last event ID before inserting new events, preventing concurrent write conflicts. The locking mechanism has been hardened with advisory locks (\pg\_advisory\_xact\_lock\) to serialize writes to the same aggregate within a transaction, and extended to support checking multiple aggregate streams in a single operation, ensuring data consistency across related entities.
Sharpino.Sample.22/db · high confidence
Refactored sample application with User aggregate and Redis L2 caching
The Sharpino.Sample.28 application has been refactored to support a new User aggregate alongside the existing Todo aggregate, enabling users to be created, renamed, and have todos assigned or detached. This change introduces domain models for both entities, including their respective events, commands, and state management, along with database migrations to store these aggregates in PostgreSQL. Additionally, the sample now demonstrates a two-level caching strategy (L1 in-memory and L2 Redis) with Redis Pub/Sub as the backplane for cache invalidation, allowing multiple application instances to stay synchronized when data changes.
Sharpino.Sample.28 · high confidence
Sample 12 adds async support and binary serialization
The Sharpino.Sample.12 project demonstrates the library's new asynchronous capabilities and binary serialization. The sample now includes async variants for state viewing and command execution (e.g., GetAllStudentsAsync, AddStudent async), allowing non-blocking operations. It also switches from the previous serialization method to binary serialization via FsPickler, as indicated by the use of PgBinaryStore and binary snapshot handling in the tests and course manager.
Sharpino.Sample.12 · high confidence
Sample 14 introduces refreshable cached details and primitive ID wrappers
The Sharpino.Sample.14 example now demonstrates the 'undoers' feature and addresses primitive obsession by wrapping Guid identifiers in strongly-typed types (CourseId, StudentId). It adds a new caching mechanism for composite read models: CourseDetails and StudentDetails are now retrieved via StateView with a built-in refresher, allowing cached data to be updated on demand. The sample also includes synchronous and asynchronous CourseManager implementations, along with RabbitMQ consumers for Course and Student aggregates that use MemoryCache for local state.
Sharpino.Sample.14 · high confidence
Sample 15 introduces refreshable cached details for enrollment data
The Sharpino.Sample.15 project demonstrates a new approach to handling enrollments by using a single, independent enrollment stream instead of embedding data in student and course streams. It introduces a 'refreshable details' feature that maintains a cache of combined student and course information, automatically keeping the view in sync with updates to the enrollment, student, or course streams.
Sharpino.Sample.15 · high confidence
Sample 24 introduces multi-aggregate domain with PostgreSQL event sourcing and L2 cache invalidation
The Sharpino.Sample.24 project now demonstrates a complete event-sourced workflow involving both User and Todo aggregates, replacing the previous single-aggregate scope. It includes domain models, commands, and events for both entities, along with SQL migrations to create the necessary PostgreSQL event and snapshot tables. The sample application is configured to use PostgreSQL as the event store and integrates an L2 cache (SQL Server) with a Service Bus message system to handle cache invalidation across multiple application instances, allowing users to test optimistic locking and real-time cache synchronization.
Sharpino.Sample.24 · high confidence
Sample.27 now demonstrates PostgreSQL-based L2 cache with message-based invalidation
The Sharpino.Sample.27 demo has been refactored to showcase a two-level caching strategy where the L2 cache is backed by PostgreSQL and synchronized across multiple application instances via PostgreSQL NOTIFY/LISTEN messages. The sample now includes configuration for a Postgres L2 cache (appSettings.json), a dedicated SQL migration script for the cache table, and shell scripts to provision and tear down the Postgres L2 cache infrastructure. The application logic has been updated to support refreshable details, allowing users to run two instances of the demo simultaneously to observe how cache invalidation messages propagate between nodes.
Sharpino.Sample.27 · high confidence
Shared entity models and API interface for sample application
The Sharpino.Sample.Shared library now defines the core data models (Category, Tag, Todo) and a REST API interface (ITodosApi) used by the sample application. Users interacting with this shared layer will find that entity definitions and the contract for todo, category, and tag operations are centralized here, supporting the Elmish client's communication with the backend service.
Sharpino.Sample.Shared · high confidence
Behavioural changes
8 commits (0 fixes) modifying Sharpino.Sample.26
A change to existing behaviour in Sharpino.Sample.26 — 8 commits, 32 files: “added pg based l2 cache and message system”; “version 6.2.7”; “added advisory\_lock on samples”; and 5 more.
Sharpino.Sample.26 · medium confidence · unverified
Binary serialization support for Course and Student aggregates
The sample application now implements binary serialization for the Course and Student domain models. New model files define the aggregates and their associated commands and events, utilizing a binary serializer for persistence instead of the previous JSON-based approach. This change affects how Course and Student state is stored and retrieved, ensuring compatibility with the binary format required by the updated sample.
Sharpino.Sample.12/Models · high confidence
Database schema and locking logic for Course, Student, and Student2 aggregates
The sample application's database layer now includes migration scripts and a schema dump for three aggregates: Course, Student, and Student2. Each aggregate is backed by dedicated event and snapshot tables (e.g., events\_01\_course, snapshots\_01\_course) with corresponding sequences, primary keys, foreign keys, and indexes on aggregate\_id and timestamp. The schema introduces a distance\_from\_latest\_snapshot column to the event tables and provides PL/pgSQL helper functions for inserting events and snapshots. Optimistic locking is enforced via database functions that verify the expected last event ID before writing, and the locking mechanism has been hardened with session-scoped advisory locks (pg\_advisory\_xact\_lock) to prevent race conditions under concurrent writes. The final migration also adds support for checking additional constraint streams alongside the primary aggregate.
Sharpino.Sample.11/db · high confidence
Database schema and optimistic locking for Course, Student, and Enrollment aggregates
The database now includes dedicated event-sourcing tables (events, snapshots, and aggregate-event mappings) for the Course, Student, and Enrollment aggregates, along with helper functions to insert events. A new distance\_from\_latest\_snapshot column has been added to the event tables to support snapshot-based recovery. Optimistic locking is enforced via database functions that verify the expected last event ID before writing; this mechanism was refined to use PostgreSQL advisory locks to prevent race conditions during concurrent writes, and extended to support checking multiple related streams in a single transaction.
Sharpino.Sample.15/db · high confidence
Database schema and optimistic locking for Material, Product, and WorkOrder aggregates
The sample database now includes initial migration files to create event-sourcing tables (events, snapshots, and aggregate-event mappings) for Material, Product, and WorkOrder aggregates, along with the necessary sequences, indexes, and helper functions. A subsequent migration grants full table and sequence permissions to the 'sharpino' user. The schema was extended by adding a 'distance\_from\_latest\_snapshot' column to the event tables for these aggregates. Finally, the database now supports optimistic locking for these aggregates via new stored functions that verify the expected last event ID before inserting new events, with the latest migration securing this check using PostgreSQL advisory locks to prevent race conditions during concurrent writes.
Sharpino.Sample.16/db · high confidence
Database schema extended with new aggregate types and optimistic locking support
The database migrations in this location introduce new event-sourcing schemas for Item, Reservation, Course, Student, Teacher, and Balance aggregates, each including dedicated events, snapshots, and aggregate-event mapping tables with appropriate indexes. Additionally, the schema was updated to support optimistic locking: a \distance\_from\_latest\_snapshot\ column was added to event tables, and new PL/pgSQL functions were created to enforce version checks on event insertion, allowing for conflict detection when multiple updates target the same aggregate.
Sharpino.Sample.9/db · high confidence
Database schema for sample sagas now includes optimistic locking and advisory locks
The database schema for the Sharpino.Sample.FormerlySaga module has been updated to support robust concurrency control for event-sourced aggregates. A new stored procedure, check\_last\_event\_id\_opt\_lock, implements optimistic locking by verifying the expected last event ID before writes, and acquires a per-aggregate advisory lock (pg\_advisory\_xact\_lock) to serialize concurrent writes to the same aggregate, preventing race conditions. Additionally, specific helper functions for inserting events into booking, row, theater, and voucher aggregates have been defined to manage event persistence and ID generation within this locking framework.
Sharpino.Sample.FormerlySaga/db · high confidence
Database schema refactoring and optimistic locking improvements
The database schema for the Ingredient, Dish, and Supplier aggregates has been refactored: event and snapshot data types changed from JSON to text, the aggregate\_state\_id column was removed from the aggregate\_events tables, and a new md column was added to events. New indexes were created on the aggregate\_id column for all event, aggregate\_event, and snapshot tables to improve query performance. Optimistic locking mechanisms were significantly enhanced: the check\_last\_event\_id\_opt\_lock function now uses PostgreSQL advisory locks to prevent race conditions during concurrent writes, and new functions were introduced to support multi-stream optimistic locking checks.
Sharpino.Sample.6/db · high confidence
Database schema updates for optimistic locking and performance
The database schema for the Goods and Cart aggregates has been updated to support optimistic locking and improve query performance. New migrations add \is\_deleted\ columns to the snapshot tables to enable soft deletes, introduce \distance\_from\_latest\_snapshot\ columns to track event proximity to snapshots, and create indexes on \aggregate\_id\ for the events, snapshots, and aggregate-events tables. Additionally, the schema now includes PL/pgSQL functions that implement optimistic locking checks using PostgreSQL advisory locks to prevent concurrent write conflicts on the same aggregate.
Sharpino.Sample.7/shoppingCartWithSharpino/db · high confidence
Database schema updates for saga aggregates
The database schema for the saga aggregates (row, booking, voucher, and theater) has been updated to support soft deletes and optimistic locking. A new \is\_deleted\ column was added to the snapshot tables for row, booking, and voucher to enable soft deletion. Additionally, an \distance\_from\_latest\_snapshot\ column was added to the event tables for these aggregates to track event distance. Optimistic locking mechanisms were strengthened by introducing \check\_last\_event\_id\_opt\_lock\ and \insert\md\\*\_aggregate\_event\_and\_return\_id\_opt\_lock\ functions, which now utilize PostgreSQL advisory locks to prevent race conditions during concurrent writes. The theater aggregate schema was also refactored to align with these patterns, changing event and snapshot storage from JSON to text and removing Kafka-specific offset fields.
Sharpino.Sample.FormerlySaga/db/migrations · high confidence
Enhanced optimistic locking with advisory locks and multi-stream checks
The database schema for the Counter and Account aggregates has been updated to support more robust concurrency control. Optimistic locking now utilizes PostgreSQL advisory locks to serialize writes to the same aggregate, preventing race conditions between the check and insert steps. Additionally, the system now supports validating the last event ID across multiple streams (extra constraints) within a single operation, and a new column tracks the distance from the latest snapshot.
Sharpino.Sample.10/db · high confidence
Enhanced optimistic locking with advisory locks and multi-stream support
The database schema for the Course and Student aggregates has been updated to provide robust optimistic locking. Initial migrations introduced the core event and snapshot tables, followed by a \distance\_from\_latest\_snapshot\ column to track event proximity. Optimistic locking was first implemented via stored functions that verify the \last\_event\_id\ before writing. This was refined with a new \check\_last\_event\_id\_opt\_lock\ function that acquires a session-scoped PostgreSQL advisory lock keyed on the aggregate, preventing race conditions under concurrent writes without schema changes. Finally, the locking functions were extended to support multi-stream consistency, allowing callers to validate the state of additional streams (via \extra\_stream\_names\, \extra\_event\_ids\, and \extra\_aggregate\_ids\) in a single transaction.
Sharpino.Sample.12/db · high confidence
Enhanced optimistic locking with advisory locks for aggregate writes
The database schema for the Todo and User aggregates has been updated to support robust optimistic locking. Initial migrations introduced the core event sourcing tables (events, snapshots, aggregate\_events) and stored procedures for inserting events. Subsequent changes added specific stored functions to validate the last event ID before writing, preventing concurrent write conflicts. The final migration replaces the previous locking check with a version that acquires a PostgreSQL session-scoped transaction advisory lock (pg\_advisory\_xact\_lock) keyed on the aggregate ID. This ensures that concurrent writes to the same aggregate are serialized at the database level, eliminating race conditions where multiple transactions might otherwise pass the optimistic check and overwrite each other's changes. A new generic check function was also added to support these locking checks across streams.
Sharpino.Sample.27/db · high confidence
Enhanced optimistic locking with advisory locks for event-sourced aggregates
The database schema for the Todo aggregate now includes robust optimistic locking mechanisms to prevent race conditions during concurrent event writes. Initial migrations establish the core event and snapshot tables along with helper functions. Subsequent updates introduce \check\_last\_event\_id\_opt\_lock\ and specialized insertion functions (\insert\_md\_01\_Todo\_aggregate\_event\_and\_return\_id\_opt\_lock\ and \opt\_lock2\) that verify the expected last event ID before allowing new events. Crucially, the final migration upgrades the locking check to use PostgreSQL session-scoped advisory locks (\pg\_advisory\_xact\_lock\), ensuring that concurrent writes to the same aggregate are serialized at the database level, thereby eliminating the risk of lost updates or phantom inserts under standard read-committed isolation.
Sharpino.Sample.25/db · high confidence
Event sourcing database schema and optimistic locking for Site and Truck aggregates
The database schema for the Site and Truck aggregates has been established with dedicated event, snapshot, and aggregate-event tables, along with helper functions for inserting events. Optimistic locking has been implemented to prevent concurrent write conflicts: initial versions check the last event ID, which was later enhanced with advisory locks to serialize writes per aggregate safely under concurrent load. The schema also supports soft deletes for snapshots and includes indexes on aggregate IDs to optimize query performance.
Sharpino.Sample.8/db · high confidence
Introduce versioned Todo domain model with context upgrade path
The sample application now defines a versioned domain model for the Todo feature, introducing an upgraded context (\TodosContextUpgraded\) and corresponding command/event types (\TodoCommand'\, \TodoEvent'\) alongside the original versions. This change adds support for bulk operations (adding multiple todos at once) and refines category reference management in the new version, while maintaining backward compatibility through explicit version markers (\\[\<CurrentVersion\>\]\, \\[\<UpgradedVersion\>\]\) and distinct storage version identifiers (\\_01\, \\_02\).
Sharpino.Sample/Domain/Todos · high confidence
Pub Management System sample refactored for Sharpino 2.0 with async support and refreshable details
The Sharpino.Sample.6 project has been updated to align with the Sharpino 2.0 API, replacing the previous \IEventBroker\-based architecture with a \MessageSenders\ model and introducing asynchronous command execution (\AddDishAsync\, \AddIngredientAsync\). The sample now demonstrates a Pub Management System that utilizes a new \RefreshableAsync\ interface for \DishDetails\, allowing clients to fetch and refresh dish data along with its ingredients efficiently. Configuration has also migrated from the legacy \sharpinoSettings\ to a structured \appSettings.json\ format, and serialization defaults to JSON via \FsPickler\.
Sharpino.Sample.6 · high confidence
Refactored sample row aggregate to use local entities and simplified serialization
The sample application in Sharpino.Sample.3/Rows has been restructured to remove dependencies on shared entity definitions, moving the Seat, Booking, and SeatsRow types into a local Entities module. Command execution now returns a tuple of the updated state and events rather than just events, and serialization has been simplified to use a default JSON parser instead of requiring an injected ISerializer interface. Additionally, the SeatsRow aggregate no longer exposes a mutable StateId or implements the Aggregate and Entity interfaces, relying instead on a generated Guid for identification.
Sharpino.Sample.3/Rows · high confidence
SQL templates now support configurable event/snapshot formats and advisory-lock optimistic concurrency
The SQL templates for aggregates and contexts have been updated to allow the event and snapshot columns to be defined as either JSON or TEXT (via a new {Format} parameter), removing the previous hard-coded JSON requirement. The aggregate template introduces a new optimistic locking mechanism using PostgreSQL advisory locks (pg\_advisory\_xact\_lock) to serialize concurrent writes to the same aggregate, replacing the previous schema-based unique constraint approach. Additionally, new stored procedures have been added to insert events with metadata (md text) and distance-from-snapshot tracking, while Kafka-specific columns (kafkaoffset, kafkapartition) and the context\_state\_id column have been removed from the templates. Several indexes on aggregate\_id and timestamp columns have also been added to improve query performance.
SqlTemplates · high confidence
Sample app configuration and shared types updated
The sample application now uses a standard appSettings.json file for configuration, replacing the previous sharpinoSettings approach, and includes a new Commons module defining shared type aliases (RowId, BookingId, VoucherId) as Guids.
Sharpino.Sample.FormerlySaga · medium confidence
Sample database schema and optimistic locking mechanism updated
The sample application's database migrations now include new tables and functions for tags, todos, and categories, establishing the underlying storage structure for these entities. Additionally, the optimistic locking function \check\_last\_event\_id\_opt\_lock\ has been updated to use PostgreSQL advisory locks (\pg\_advisory\_xact\_lock\), ensuring that concurrent writes to the same aggregate are serialized and preventing race conditions that could occur with the previous plain SELECT approach.
Sharpino.Sample/db/migrations · high confidence
Shopping cart sample now uses binary serialization
The shopping cart sample in the \shoppingCartWithSharpinoBinary\ directory has been updated to use binary serialization instead of the previous format. This change involves new implementations for the Cart aggregate, commands, events, and a RabbitMQ consumer, all utilizing \FsPickler\ for binary serialization and deserialization of state and messages.
Sharpino.Sample.7/shoppingCartWithSharpinoBinary/Cart · high confidence
Stadium Seat Booking sample refactored to use new event sourcing APIs
The Sharpino.Sample.3 project, a Stadium Seat Booking System example, has been restructured to align with updated library interfaces. Command handlers now implement \AggregateCommand\ instead of \Command\, and event/aggregate serialization uses a dedicated \jsonPSerializer\ rather than accepting an \ISerializer\ parameter. The system initialization has shifted from synchronous to asynchronous via \runInitAsync\, and the event broker pattern is replaced by explicit \MessageSenders\ for notification. Additionally, the \Stadium\ aggregate now uses a fixed unique ID instead of generating a new one per instance, and state viewers return simplified tuples.
Sharpino.Sample.3 · high confidence
Stadium and Seatrow aggregates: new schema, optimistic locking, and advisory locks
The sample application's database schema for the Stadium and Seatrow aggregates has been updated. The underlying tables now store events and snapshots as text rather than JSON, and include new columns for optimistic locking metadata (distance\_from\_latest\_snapshot, md) and deletion status. New stored functions have been added to support optimistic locking checks on aggregate writes, ensuring that concurrent updates to the same aggregate are serialized. Additionally, an advisory lock mechanism has been introduced to prevent race conditions during event insertion, providing stronger consistency guarantees for these specific aggregates.
Sharpino.Sample.3/db/migrations · high confidence
Supplier domain model and event-driven processing updated
The Suppliers sample now implements the Supplier aggregate as a class with explicit ChangePhone and ChangeEmail commands that produce PhoneChanged and EmailChanged events. A new background consumer connects to RabbitMQ, maintains an in-memory state cache, and processes incoming events to keep the aggregate state current.
Sharpino.Sample.6/Suppliers · high confidence
Updated sample aggregates to use new command interface and simplified types
The Dishes and Ingredients sample modules have been refactored to align with the framework's updated patterns. Commands now implement the \AggregateCommand\ interface, which returns a tuple of the new state and the list of events, replacing the previous \Command\ interface. Additionally, the \Dish\ and \Ingredient\ types have been simplified by removing explicit \Aggregate\ and \Entity\ interface implementations and the \StateId\ property, while the event and command modules have been moved from nested module structures to top-level types. New \Consumer.fs\ files have been added for both Dishes and Ingredients to handle RabbitMQ message consumption as background services.
Sharpino.Sample.6/Dishes · high confidence
Test coverage
3 commits adding/updating tests in Sharpino.Sample.24.Test, Sharpino.Sample.26.Test, Sharpino.Sample.27.Test; 3 commits adding/updating tests in Sharpino.Sample.28.Test; Added database migration scripts for sample event-sourcing tests; Added database schema and helper functions for event store tests; Added integration tests for the Saga sample application; Added integration tests for the Transport Tycoon network simulation; Added seat booking sample tests; Added test models for ContextObject and SampleObject aggregates; Added test suite for Stadium Seat Booking sample; Added test suite for multi-tier aggregate caching and event store operations; Added test suite for the PubSystem sample; Initial test suite for Sharpino sample application.
Dependencies
Sharpino library and samples target .NET 10 alongside .NET 9 and 8
The Sharpino event sourcing library and its accompanying sample applications now support .NET 10.0 as a primary target framework, in addition to existing support for .NET 9.0 and .NET 8.0. This update aligns the core library (Sharpino.Core and Sharpino.Lib) and the various sample projects with the latest .NET runtime, ensuring compatibility with modern .NET features and performance improvements while maintaining backward compatibility with previous LTS and current releases.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 45 → 46 (+0.6)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 65 → 64 (-0.9)
- Architecture 69 → 69 (+0.5)
- Maturity 48 → 50 (+1.8)
- Readiness 32 → 32 (+0.0)
- Security 69 → 84 (+14.4)
- Performance 61 → 60 (-1.3)
Resolved (40)
- Change coupling: AppVersions.fs ↔ Commands.fs (Sharpino.Sample/AppVersions.fs)
- Change coupling: Commands.fs ↔ Commands.fs (Sharpino.Sample/Domain/Tags/Commands.fs)
- Change-coupling hub: Commands.fs → AppVersions.fs, Commands.fs, Context.fs, Events.fs, Commands.fs (Sharpino.Sample/Domain/Categories/Commands.fs)
- Change-coupling hub: Events.fs → AppVersions.fs, Commands.fs, Context.fs, Events.fs (Sharpino.Sample/Domain/Categories/Events.fs)
- Change-coupling hub: Events.fs → AppVersions.fs, Commands.fs, Context.fs, Events.fs, Commands.fs, Context.fs, Events.fs (Sharpino.Sample/Domain/Todos/Events.fs)
- Change-coupling hub: Events.fs → AppVersions.fs, Context.fs, Commands.fs (Sharpino.Sample/Domain/Tags/Events.fs)
- Coverage not measured — no coverage collector is wired up
- Documentation: no project overview (Sharpino.Sample/README.md)
- Duplicated block (10 lines × 4) (Sharpino.Lib/CommandHandler.fs)
- Duplicated block (13 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (13 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (13 lines × 2) (Sharpino.Lib/PgEventStore.fs)
- Duplicated block (13 lines × 2) (Sharpino.Lib/StateView.fs)
- Duplicated block (13 lines × 2) (Sharpino.Sample.7/shoppingCartWithSharpino/GoodsContainer/Events.fs)
- Duplicated block (14 lines × 2) (Sharpino.Sample.7/shoppingCartWithSharpino/Goods/Events.fs)
- Duplicated block (16 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (16 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (17 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (19 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (19–20 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- …and 20 more
New (57)
- AggregateCache3.SetupL2AndBackplane (cyclomatic 19) (Sharpino.Lib/Cache.fs)
- Duplicated block (10 lines × 2) (Sharpino.Sample.11/Models/Course/Events.fs)
- Duplicated block (10 lines × 2) (Sharpino.Sample.7/shoppingCartWithSharpino/Cart/Events.fs)
- Duplicated block (10 lines × 5) (Sharpino.Lib/CommandHandler.fs)
- Duplicated block (10 lines × 6) (Sharpino.Sample.22/Domain/Todo/Events.fs)
- Duplicated block (10–11 lines × 2) (Sharpino.Lib/PgEventStore.fs)
- Duplicated block (11 lines × 2) (Sharpino.Lib/PgEventStore.fs)
- Duplicated block (11 lines × 2) (Sharpino.Sample.11/Models/Student/Events.fs)
- Duplicated block (11 lines × 2) (Sharpino.Sample.12/Models/Student/Events.fs)
- Duplicated block (11 lines × 4) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (11–12 lines × 4) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (12–13 lines × 4) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (12–14 lines × 2) (Sharpino.Lib/MemoryStorage.fs)
- Duplicated block (13 lines × 4) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (13–14 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (15 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (15 lines × 2) (Sharpino.Sample.7/shoppingCartWithSharpino/GoodsContainer/Events.fs)
- Duplicated block (16 lines × 2) (Sharpino.Lib/PgBinaryEventStore.fs)
- Duplicated block (16 lines × 2) (Sharpino.Lib/PgEventStore.fs)
- Duplicated block (16 lines × 2) (Sharpino.Lib/Sanitizer.fs)
- …and 37 more
Changes since last survey
- 7 commits — 7 feature/other, 0 fixes
By area
- (root) — 3 commits
- Sharpino.Lib.Test/AggregateCache3Tests.fs — 1 commit
- Sharpino.Lib.Test/EvolveSkippingErrorsTests.fs — 1 commit
- Sharpino.Lib.Test/Models — 1 commit
- Sharpino.Sample.7/shoppingCartWithSharpino — 1 commit
Notable commits
- change: Added doc on sharding
- change: added more L1/L2 cache related test cases
- change: note about codeassuranceindex
- change: readme vers. 7.0.1
- change: sanytize events on event store
- change: test on the "skip" error core workaround
- change: version 7.0.1 (change "evolve/_un_forgiving" tecnique)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
tonyx/Sharpino 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.
About this page
- The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 9daceddd66348d029191f85289115de0338be193 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-b921b700395b.