zilverline/sequent
59.7
Adequate · 10 November 2026
9.8k
lines of production code
Ruby
primary language
10
measurements over time
What this system is
Features
Added template files for a sample aggregate generator
The \lib/sequent/generator/template\_aggregate\ directory now contains a complete set of Ruby files defining a sample \TemplateAggregate\ aggregate root, its associated \AddTemplateAggregate\ command, \TemplateAggregateAdded\ event, and the corresponding command handler. These files serve as a structural template for generating new aggregates, providing a concrete example of how commands, events, and handlers are wired together within the Sequent framework.
_lib/sequent/generator/template\aggregate · high confidence
Introduce message matcher DSL for flexible test assertions
The library now provides a new message matching DSL under \lib/sequent/core/helpers/message\_matchers\ that allows users to write more expressive and flexible assertions in tests. This includes built-in matchers such as \has\_attrs\ (which supports nested attribute matching and can wrap other matchers), \is\_a\ (with an optional \except\ clause to exclude specific subclasses), \instance\_of\, and \any\ (also supporting \except\). The system uses an \ArgumentCoercer\ to automatically wrap raw classes or modules into matchers, and an \ArgumentSerializer\ to generate readable descriptions for failure messages. Custom matchers can be registered globally via the DSL, enabling extensibility for specific testing needs.
_lib/sequent/core/helpers/message\matchers · high confidence
Introduce middleware chain infrastructure
A new middleware system is introduced in the core library, starting with the definition of a \Middleware\ class that serves as the entry point for the chain. This change establishes the foundational structure for processing commands through a series of middleware components, enabling extensible request handling within the application's core.
lib/sequent/core/middleware · high confidence
Introduce sequent CLI executable
A new \bin/sequent\ executable has been added to the project, serving as the entry point for the command-line interface. It initializes the CLI application using the \gli\ and \tty-prompt\ libraries, delegating command execution to \Sequent::Cli::App\. This change establishes the foundational structure for user-facing commands, although the specific command implementations (such as \new\, \generate\, or \migrate\) are handled in other parts of the codebase.
bin · high confidence
New Sequent CLI with interactive project scaffolding and migration support
The Sequent CLI has been rewritten to use the GLI and TTY::Prompt libraries, providing a more interactive and user-friendly command-line experience. Users can now scaffold new Sequent projects using the \sequent new\ command, which guides them through setup steps. The CLI also supports generating aggregates, commands, and events via the \sequent generate\ command, offering immediate feedback on success or errors (such as missing aggregates). Additionally, a new \sequent migrate\ command has been added to assist users in migrating their projects from Sequent 7 to Sequent 8, handling potential dependency issues gracefully.
lib/sequent/cli · high confidence
New attribute matcher DSL and serialization support
The library now provides a dedicated DSL for defining and using attribute matchers (such as equals, not equals, greater than, less than, etc.) within the \AttrMatchers\ module. This change introduces an \ArgumentSerializer\ to handle the serialization of matcher values, including nested hashes, ensuring that complex matcher expressions are correctly formatted. The previous \BooleanSupport\ module has been refactored into this new DSL structure, allowing users to register custom matchers and use them in assertions with proper string representation.
_lib/sequent/core/helpers/attr\matchers · high confidence
New command and event generators for aggregates
The generator now supports creating commands and events for existing aggregates via dedicated classes (lib/sequent/generator/command.rb and lib/sequent/generator/event.rb). These generators append the new command or event definitions to the aggregate's commands.rb and events.rb files, and inject the corresponding handler logic into the aggregate's command handler or domain model file using AST-based parsing to ensure correct insertion. This allows users to extend an aggregate with new behaviors without manually editing the aggregate's core files.
lib/sequent/generator · high confidence
New configuration and core API entry points
Sequent introduces a centralized configuration system via \Sequent::Configuration\, allowing users to customize settings such as schema names, replay process counts, and autoregistration behavior through a \Sequent.configure\ block. The main library now exposes convenient class shortcuts (e.g., \Sequent::Event\, \Sequent::Command\) and utility methods like \Sequent.new\_uuid\ and \Sequent.dry\_run\, simplifying the setup and usage of the framework.
lib/sequent · high confidence
New database support module for schema and connection management
A new \Sequent::Support::Database\ class has been introduced to centralize PostgreSQL database operations, including schema creation and dropping, connection establishment, and SQL execution. This module leverages ActiveRecord's task infrastructure for database creation and dropping, while providing custom helpers for managing search paths and lock timeouts within blocks. It also includes logic to check for schema existence, accounting for changes in ActiveRecord 7.1's schema dumping behavior, and ensures proper handling of database configurations and connections for Sequent applications.
lib/sequent/support · high confidence
New rake tasks for managing Sequent database migrations and schema
This change introduces a new set of rake tasks under the \sequent\ namespace to handle database schema and migration management. It adds \sequent:install:migrations\ to copy Sequent migration files into the project's \db/migrate\ directory, and \sequent:db:migrate\ to apply event store migrations using ActiveRecord. It also includes tasks for creating and managing the view schema (\sequent:db:create\_view\_schema\), dumping and loading the database structure while excluding internal Sequent schemas, and registering aggregate root, command, and event types. These tasks provide a structured way to initialize and maintain the Sequent event store and view schemas alongside standard ActiveRecord migrations.
lib/sequent/rake · high confidence
New transaction providers for read-only and no-transaction modes
The core transaction subsystem now includes new provider classes: \NoTransactions\ (used during view schema upgrades to skip transactional overhead) and \ReadOnlyActiveRecordTransactionProvider\ (wraps existing providers to enforce read-only mode via \SET TRANSACTION READ ONLY\). These are wired together in \transactions.rb\ to allow the system to operate without defaulting to nested transactions and to support dry-run scenarios.
lib/sequent/core/transactions · high confidence
New utility modules for dry-run simulation, error printing, and cache clearing
This change introduces several new utility components in \lib/sequent/util\. The \DryRun\ module allows users to inspect what would happen if commands were executed without actually committing results, including which projectors and workflows would be invoked. A new \Printer\ module provides recursive error logging for debugging. \SkipIfAlreadyProcessing\ offers thread-local locking to prevent re-entrant processing, and \Timer\ adds simple performance logging. Additionally, a \ClearCache\ middleware is added to automatically clear the aggregate repository cache after each web request.
lib/sequent/util · high confidence
Sequent 8 migration tool and core event handling infrastructure
This change introduces the Sequent 8 migration CLI (\Sequent8Migration\) to guide users through upgrading their database schema and data, including partitioning support for aggregates, commands, and events. It adds a queue-based \EventPublisher\ to ensure events are published in order within a thread, a \Middleware::Chain\ for extensible command processing, and new internal models (\PartitionedAggregate\, \PartitionedEvent\, etc.) to support partitioned storage. Additionally, it provides a new \ApplicationRecord\ base class, updates \CommandRecord\ serialization to use \Oj\, and adds integration specs for a Rails application to demonstrate the new structure.
sequent · high confidence
Removals
Removal of Sinatra-specific web helpers
The Sinatra-specific form rendering components (including \Form\, \Fieldset\, \TagHelper\, and \FormHelpers\) have been removed from the \lib/sequent/web\ directory. This change eliminates the built-in support for generating HTML forms and tags within the Sinatra framework, effectively decoupling the core web library from Sinatra-specific implementation details.
lib/sequent/web · high confidence
Removal of in-memory replay event session
The \ReplayEventsSession\ class and its associated \RecordSessions\ module have been removed from the core library. This change eliminates the in-memory mechanism previously used for replaying events, which relied on dynamic struct generation and CSV-based bulk insertion via \ActiveRecord\'s \COPY\ command. Users relying on this specific in-memory replay implementation for testing or data migration will need to adopt alternative approaches.
_lib/sequent/core/record\sessions · high confidence
Behavioural changes
Autoregistration of command handlers, projectors, and observers
The integration spec now verifies that Sequent's autoregistration feature automatically discovers and registers command handlers, projectors, workflows, and aggregate observers. Users can enable this behavior via \config.enable\_autoregistration = true\, which automatically includes classes like \FirstCommandHandler\ and \AggregateSnapshotter\ without manual configuration, while allowing specific classes to opt out using \skip\_autoregister\.
integration-specs/simple · high confidence
Event store schema overhaul with versioned snapshots and projector state tracking
The database schema for the event store has been significantly restructured to support advanced snapshotting and projector management. The initial schema now creates separate event store and view schemas, introducing tables for command types, aggregate types, event types, and partitioned tables for commands, aggregates, and events. A key behavioral change is the introduction of versioned snapshots: the \aggregates\_that\_need\_snapshots\ and \snapshot\_records\ tables now include a \snapshot\_version\ column, allowing multiple snapshot versions per aggregate and changing the primary keys to include this version. Additionally, new tables \projector\_states\ and \replay\_states\ have been added to track projector lifecycle and replay progress, including constraints to prevent conflicting replay and activation states. The schema also includes a \partition\_key\_changes\ table to track changes to aggregate partition keys and a \saved\_event\_records\ table for audit purposes. Stored procedures for storing events, aggregates, and snapshots have been versioned and updated to support these new structures, including locking mechanisms for aggregate updates and fixes to sequence number checks.
db/migrate · high confidence
Event store snapshotting and event storage logic refactored for versioning and concurrency safety
The database migration scripts in db/migrate/sequent have been updated to support multiple snapshot versions per aggregate, allowing the system to handle evolving snapshot schemas without invalidating existing data. Snapshot-related functions (load, store, delete, and selection) now accept a \_snapshot\_version\_by\_type parameter to filter and manage specific versions. Additionally, the event storage procedure (store\_events) now enforces strict sequence number continuity checks to prevent gaps or overlaps during concurrent writes, and uses row-level locking (FOR NO KEY UPDATE) to ensure data integrity when updating aggregates and unique keys.
db/migrate/sequent · high confidence
Initialize library structure and bump version to 8.2.0
The library now includes a central entry point (lib/sequent.rb) that loads core components such as the application record, core logic, utilities, migrations, and dry-run functionality, along with a dedicated notices file for managing deprecation warnings to reduce log noise. Additionally, the library version has been updated to 8.2.0.
lib · high confidence
Internal module for partitioned storage and key change tracking
The internal module at lib/sequent/internal has been consolidated into a single entry point (internal.rb) that explicitly requires the core types (AggregateType, CommandType, EventType) and the new partitioned storage classes (PartitionedAggregate, PartitionedCommand, PartitionedEvent) along with PartitionKeyChange. This change organizes the internal implementation details for tracking event partition key changes and managing partitioned storage, making these components available through a unified internal interface without altering the public API.
lib/sequent/internal · medium confidence
Introduce Projectors, Workflows, and Aggregate Observers with versioned projector activation
Sequent now provides three distinct mechanisms for reacting to domain events: Projectors for updating view models, Workflows for executing commands after a transaction commits, and Aggregate Observers for immediate in-domain side effects. Projectors support per-projector versioning and are managed by a new ActiveProjectorsEventPublisher, which ensures events are only dispatched to projectors marked as active in the database, allowing safe zero-downtime upgrades. The legacy BaseEventHandler and TenantEventStore have been removed in favor of these new abstractions, and snapshotting logic has been moved into the AggregateRoot with configurable thresholds.
lib/sequent/core · high confidence
Introduce Sequent 8 event store schema with partitioning and migration support
The database layer now uses a new Sequent 8 schema structure that replaces the previous flat table design with partitioned tables for commands, aggregates, and events to improve scalability. This change includes a dedicated migration script (\sequent\_8\_migration.sql\) to upgrade existing databases while preserving data, and a new \database.yml\ configuration file for local test environments. The schema introduces separate tables for aggregate types, event types, and command types, along with a new \aggregates\_that\_need\_snapshots\ table to track snapshot requirements and high-water marks, enabling more efficient snapshot management and replay strategies.
db · high confidence
New offline migration strategy with dry-run support and projector versioning
The migration system has been restructured to support zero-downtime (offline) deployments by introducing a 3-phase execution model (online replay, offline table swap, cleanup) managed by the new \Executor\ and \Planner\. A new \AlterTable\ migration type allows schema changes without full replay, and projectors now support per-projector versioning for seamless upgrades. To help users validate performance before committing, a new \migrate:dryrun\ task and \DryRun::ViewSchema\ class allow simulating the replay process without writing to the database. The legacy \MigrateEvents\ class has been removed in favor of this new approach.
lib/sequent/migrations · high confidence
Persistor module restructured with new interface and optimized bulk loading
The core persistence layer has been reorganized under the new \Sequent::Core::Persistors\ namespace, replacing the previous \RecordSessions\ module. A new \Persistor\ interface defines the standard methods for record operations, which are implemented by \ActiveRecordPersistor\ and \ReplayOptimizedPostgresPersistor\. The \ActiveRecordPersistor\ now supports bulk record creation via \insert\_all!\ and exposes \prepare\/\commit\ hooks for transaction management. The \ReplayOptimizedPostgresPersistor\ introduces an in-memory index system that splits multi-column where-clauses into single-column indexes, using set intersection for efficient lookups during bulk replay operations. Also in this area: 7 commits (0 fixes) modifying lib/sequent.
lib/sequent/core/persistors · medium confidence · unverified
Refactored core helpers with new validators and message handling
The \lib/sequent/core/helpers\ module has been significantly restructured to improve type safety and validation. New dedicated validators have been introduced for Boolean, Date, DateTime, String, and Time attributes, replacing previous inline checks. The \SelfApplier\ module has been removed and replaced by a new \MessageHandler\ that supports a DSL for registering multiple event handlers via the \on\ method, including support for options and argument coercion. Additionally, \AttributeSupport\ now integrates \DefaultValidators\ to automatically apply these validations when attributes are defined, and \ParamSupport\ has been updated to handle form data submission and stricter nil checking.
lib/sequent/core/helpers · high confidence
Sequent 9.x introduces zero-downtime deployment support and removes internal database connection management
Sequent now supports zero-downtime (rolling) upgrades by tracking projector states in a new \projector\_states\ table and requiring the \ActiveProjectorsEventPublisher\ to ensure events are only published to active projectors with the correct version. To facilitate this, snapshots can now be versioned, allowing old and new code to coexist during deployment. Additionally, Sequent no longer manages database connections internally; this responsibility is now delegated to the hosting application (e.g., Rails or Sinatra), and configuration options like \database\_config\_directory\ have been removed. The changelog also notes that Sequent 8.0+ requires Ruby 3.2, ActiveRecord 7.1, and PostgreSQL 14, and utilizes PostgreSQL stored procedures for event storage.
(repo-wide) · high confidence
Standardized JSON deserialization and type handling for core Ruby types
The core extension library now provides explicit, standardized methods for deserializing JSON data into native Ruby types, including Symbol, String, Integer, Float, BigDecimal, Boolean, Date, DateTime, Time, Array, and Hash. This change introduces robust handling for nil and blank values across these types, ensures BigDecimal uses the non-deprecated constructor, and adds specific fallback logic for Time parsing to maintain compatibility across Ruby versions (including 2.7 and 3.x). Users will experience more consistent and reliable data conversion when loading records from JSON, with improved error handling for invalid date/time formats.
lib/sequent/core/ext · high confidence
Template project now includes standard Active Record database configuration and migrations
The generated template project now ships with a \database.yml\ file configured for PostgreSQL (using \sequent\_schema\ and \view\_schema\ in the search path) and a sample Active Record migration (\CreatePostRecords\) that creates a \post\_records\ table within the view schema. This allows users to leverage standard Active Record database migrations for managing their view models out of the box.
_lib/sequent/generator/template\project/db · high confidence
Template project now uses Post domain instead of Account
The generated template project has been updated to use a Post domain model instead of the previous Account model. This involves replacing the AccountRecord with a new PostRecord that inherits from Sequent::ApplicationRecord, and introducing a PostProjector to handle events such as PostAdded, PostAuthorChanged, PostTitleChanged, and PostContentChanged, thereby changing the structure and behavior of the generated application's core domain logic.
_lib/sequent/generator/template\project/app · high confidence
Template project now uses a Post domain model instead of Account
The generated template project has switched its example domain from an Account entity to a Post entity. This change updates the core domain logic, introducing a Post aggregate root that handles commands to add a post with author, title, and content, and emits corresponding events (PostAdded, PostAuthorChanged, etc.). The template now includes the necessary command handler and event definitions to support this new Post-based workflow.
_lib/sequent/generator/template\project/lib · high confidence
Template project now uses environment-based configuration and explicit initializer loading
The generated template project has been restructured to support environment-specific configuration via the SEQUENT\_ENV variable (defaulting to 'development') and explicit initializer loading. The Rakefile now sets the environment variable and registers migration tasks, while the main application file (my\_app.rb) explicitly requires database and Sequit initializers from the config/initializers directory, replacing previous implicit or file-based configuration methods.
_lib/sequent/generator/template\project · high confidence
Template project now uses initializers for database and autoregistration configuration
The template project's configuration has been refactored to use dedicated initializer files. Database settings are now explicitly loaded from \db/database.yml\ and configured for the correct environment and directory via a new \active\_record.rb\ initializer. Additionally, the \sequent.rb\ initializer enables the autoregistration feature, ensuring that projectors and other components are automatically registered without manual intervention.
_lib/sequent/generator/template\project/config · high confidence
Test coverage
Add Rails integration spec template; Added comprehensive test suite for Sequent Core components; Added database schema fixtures for projector tests; Added test coverage for ActiveRecord and ReplayOptimizedPostgres persistors; Added test coverage for core helper components; Added test coverage for message matcher helpers; Added test coverage for the Sequent generator components; Added test fixtures for attribute support validation; Added test fixtures for commands, events, and aggregate roots; Added tests for ActiveRecord transaction providers; Added tests for Post command handler in template project; Added tests for PostProjector; Added tests for Sequent::Support::Database utility; Added tests for attribute matchers and argument serialization; Added tests for configuration autoregistration and migration class setup; Added tests for migration file timestamp handling; Added tests for migration grouper, planner, replayer, and view schema logic; Added tests for partitioned storage and partition key change handling; Added tests for test helper integration and time comparison utilities; Added tests for the dry run command execution feature; Added tests for the middleware chain implementation; New test helpers for command handlers, workflows, and event streams; Refactored test infrastructure and removed legacy specs; Updated test environment configuration for generated projects.
Dependencies
Add support for Active Record 7.2, 8.0, and 8.1
The gemfile test suite now includes dedicated configurations for Active Record 7.2.1, 8.0.1, and 8.1.2, allowing the library to be tested against these specific versions of the Active Record framework.
gemfiles · high confidence
Major dependency upgrade and Ruby version requirement increase
The Sequent gem now requires Ruby 3.2 or higher and has significantly updated its dependencies to support modern versions of Active Record (7.2.1+) and OJ (\~\> 3.3). The gemspec has been updated to include new dependencies such as \bcrypt\, \csv\, \gli\, \logger\, \parallel\, \parser\, \pg\ (\~\> 1.2), \prism\, and \tty-prompt\, while removing older constraints like \activerecord \~\> 4.0.10\. Additionally, the \sequent\ executable is now included in the gem, and the list of authors and maintainers has been expanded.
(dependencies) · high confidence
Housekeeping
Added placeholder file in tmp directory
A new .gitkeep file was added to the tmp directory to ensure the directory is tracked by version control.
tmp · 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 52 → 60 (+7.6)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 64 → 64 (+0.1)
- Architecture 84 → 86 (+1.6)
- Maturity 34 → 49 (+14.8)
- Readiness 59 → 59 (+0.1)
- Security 79 → 91 (+12.0)
- Domain Modelling 100 → 100 (+0.0)
- Event Sourcing 100 → 100 (+0.0)
Resolved (14)
- Ambiguous distinction between 'find' and 'load'. In many ORMs, 'find' implies a database lookup that might return nil, while 'load' might imply raising an error or loading from cache. Here, both take an ID and a class. Without documentation, it is unclear if they differ in caching behavior, error handling, or whether one loads projections/hydrates the aggregate differently. The naming suggests a semantic difference that is not immediately obvious from the signature.
- Ambiguous singular vs plural naming for similar retrieval operations. load_event takes a sequence number, implying it loads a specific version, while load_events takes only an aggregate ID, implying it loads all versions. However, the naming convention is inconsistent with load_aggregate (singular) vs load_aggregates (plural) in the Repository, and load_events_for_aggregates (plural). The distinction between 'loading a specific event by version' and 'loading all events for an aggregate' is obscured by the lack of a clear 'all' or 'history' keyword in the singular method name.
- Documentation: contradicts the code (docs/docs/concepts/aggregate-repository.md)
- Duplicate intent with different names. Both methods check for the existence of data associated with an aggregate ID. In event sourcing, 'stream' and 'events' are often synonymous in this context. Having two boolean check methods with different names for the same underlying concept is confusing.
- Inconsistent bang method usage. In Ruby, clear! often implies a more aggressive or irreversible action than clear, or simply that it bypasses some safety check. However, without clear documentation, it is ambiguous why two clear methods exist. If clear! is just a forceful clear, it should be documented. If they are functionally identical, it is redundant.
- Inconsistent naming for deletion operations. permanently_delete_event_stream deletes events. permanently_delete_commands_without_events deletes commands. The naming convention shifts from 'event_stream' to 'commands_without_events'. It is unclear if permanently_delete_event_streams (plural) is just the batch version of the singular, or if there is a semantic difference. The third method is very specific about what it deletes, while the first is generic about 'event stream'.
- No SBOM
- No artifact signing
- No build provenance
- Off-boarding risk: anonymized user #1
- Orphaned file (lib/sequent/generator/event.rb)
- Outdated: prism
- Outdated: web-console
- Unpinned build actions
New (14)
- FileTooLong: migrations/projectors_replayer.rb (lib/sequent/migrations/projectors_replayer.rb)
- Off-boarding risk: anonymized user #1
- Orphaned file (integration-specs/rails-app/config/environments/development.rb)
- Orphaned file (integration-specs/rails-app/config/environments/production.rb)
- Orphaned file (lib/sequent/cli/app.rb)
- Orphaned file (lib/sequent/cli/sequent_8_migration.rb)
- Orphaned file (lib/sequent/core/helpers/association_validator.rb)
- Orphaned file (lib/sequent/core/helpers/attribute_support.rb)
- Orphaned file (lib/sequent/core/helpers/param_support.rb)
- Orphaned file (lib/sequent/core/helpers/secret.rb)
- Orphaned file (lib/sequent/core/helpers/string_to_value_parsers.rb)
- Orphaned file (lib/sequent/migrations/executor.rb)
- Orphaned file (lib/sequent/migrations/planner.rb)
- Orphaned file (lib/sequent/util/dry_run.rb)
Changes since last survey
- 47 commits — 45 feature/other, 2 fixes
By area
- lib/sequent — 19 commits
- (root) — 11 commits
- (repo) — 9 commits
- spec/lib — 5 commits
- docs/docs — 2 commits
- benchmarks/replay_persistor.rb — 1 commit
Notable commits
- fix: Merge pull request #548 from zilverline/fix/ruby-regexp-cves
- fix: Move to the Ruby releases that fix the Onigmo regexp CVEs
- change: Add a benchmark for the replay optimized persistor
- change: Add before, after and around hooks to message handlers
- change: Allow specific write callbacks on projection records
- change: Allow the callbacks ActiveRecord adds itself through the default
- change: Always load the records using COPY
- change: Avoid allocations per record when tracking computed columns
- change: Check projection record callbacks in specs instead of in projectors
- change: Check that matching an InstanceOf returns a copy of its handlers
- change: Check that replaying flushes the own replay persistor of a projector
- change: Describe read-only projection records in the projector docs
- change: Describe the replayer changes for subclasses in the changelog
- change: Do not allow write callbacks or validations on projection records
- change: Do not let code other than projectors delete projection records
- change: Encode the COPY values with the C encoders of the pg gem
- change: Fail a spec when ActiveRecord adds a relation write method
- change: Inherit hooks that are added to a superclass later
- change: Invoke handlers directly without hooks, and skip after hooks on failure
- change: Let applications skip the projection record callback check
- …and 27 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
zilverline/sequent 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 10 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 7aaf79d90a9b198ad7453faa2c269ff9ba5c262d — 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.4+preprod-464a0040a931.