SpineEventEngine/core-jvm

This system is a server-side framework for building event-driven applications using a bounded context architecture. It manages the lifecycle of entities, process managers, and projections by processing commands and events through a structured bus and delivery system. The framework provides client libraries for issuing requests and querying state, along with comprehensive tools for testing, multi-tenancy, and distributed tracing.

74 changes.

This period focused on a comprehensive redesign of the server framework, shifting from legacy event-sourced aggregates to direct state mutation and introducing a robust multi-tenancy infrastructure. The work established new core abstractions for commands, events, and entities, while adding critical features like bounded context integration, sharded delivery, and a system monitoring context. Extensive test coverage was added to validate the new model classes, routing logic, and tenant-aware operations across the client and server modules.

54 changes.

This period focused on restructuring the server core to support Bounded Contexts, introducing a generic event enrichment framework, and implementing comprehensive system-level tracing and lifecycle tracking. Concurrently, the project migrated significant portions of the server and client codebases to Kotlin, establishing new idiomatic APIs for queries, commands, and event handling while maintaining Java compatibility.

57 changes.

This period focused on migrating core server infrastructure—including routing, aggregates, process managers, and projections—from Java to Kotlin, while introducing new features like OpenTelemetry tracing and entity history storage. Concurrently, the team significantly expanded test coverage by adding comprehensive Kotlin test suites, new test fixtures for various contexts, and a robust black-box integration testing framework.

The transport protocol definition now includes a new \ChannelId\ message within the \spine.server.transport\ package. This message identifies a transport channel by specifying the type URL of the messages transmitted through it, enabling clients and servers to distinguish between different message types on the same transport layer.

server/src/main/proto/spine/server/transport · high confidence

A new \DoNothing\ command message has been added to the \spine.server.command\ package. This system command is designed for scenarios where a commanding method does not produce any output in response to an event. The framework treats this command specially: it is never posted for processing after being emitted, nor is it stored, and no handlers can be registered for it.

server/src/main/proto/spine/server/command · high confidence

Introduced a new guidelines document for the Junie AI agent that outlines project navigation, code editing, and testing best practices, alongside a symlink to the shared skills directory to enable agent-specific assistance workflows.

.junie · high confidence

The server now includes a migration tool (\MirrorMigration\) that converts deprecated \Mirror\ projections into the new per-aggregate \EntityRecordStorage\ format used in Spine 2.0. This process runs in configurable batches via \MirrorMigrationMonitor\, transforming legacy mirror records into \RecordWithColumns\ using \MirrorToEntityRecord\ and writing them to the appropriate aggregate-specific storage. The migration respects the \wasMigrated\ flag to avoid duplicates and supports pausing/resuming via the monitor interface.

server/src/main/java/io/spine/server/migration · high confidence

New Protocol Buffers definitions have been added to the \server/src/testFixtures/proto/spine/server/given/context/sorting\ directory to support server-side testing. These files define the \Figure\ message (with circle, triangle, and square variants), a \Sorter\ view that accumulates figures into buckets, and a \FigureStats\ view for counting generated figures. Additionally, command and event messages (\GenerateFigures\ and \FigureGenerated\) are introduced to facilitate the generation and tracking of these geometric figures within the test context.

server/src/testFixtures/proto/spine/server/given/context/sorting · high confidence

New \.proto\ files have been added to the \server/src/testFixtures/proto/spine/server/given/context/counting\ directory to define a sample context used for testing. This includes a \Range\ message for integer bounds, a \GenerateNumbers\ command to request random number generation, a \NumberGenerated\ event, and \RangeStats\ and \NumberStats\ view entities to track generation statistics. These definitions provide the schema foundation for the counting context test fixture.

server/src/testFixtures/proto/spine/server/given/context/counting · high confidence

Added a new set of automation scripts in \scripts/dependent-repositories\ to automatically synchronize the \core-java\ library dependency across dependent repositories. The \update-dependent-repositories.sh\ entry point triggers specific scripts (\gae-update-core-version.sh\ and \jdbc-update-core-version.sh\) which use \update-dependency-version.sh\ to fetch the latest version from the \core-java\ repository, update the corresponding \ext.gradle\ files in \gae-java\ and \jdbc-storage\, and create pull requests to merge these changes.

scripts/dependent-repositories · high confidence

This change introduces the initial Claude Code configuration for the project. It adds a SessionStart hook that pre-warms the Gradle dependency cache in web sessions to ensure faster build times. It also defines permissions allowing routine build and git commands, and sets up hooks for initializing submodules, scanning for secrets, and sanitizing source code.

.claude · high confidence

A new \MirrorsMigrated\ message has been added to the \spine.server.migration.mirror\ package to track the number of mirror projections migrated in a single request. This message includes an integer value representing the batch size, which is dictated by the \MirrorMigrationMonitor\, allowing the system to report how many records were processed in each migration step.

server/src/main/proto/spine/server/migration · high confidence

The server now exposes a new tracing API in the \io.spine.server.trace\ package, enabling integration with external tracing systems to monitor message processing. The API centers on \TracerFactory\, which creates \Tracer\ instances for individual signals, and \Tracer\, which records which entity (identified by \MessageId\ and \EntityTypeName\) processed a signal. This functionality is currently limited to entities such as Aggregates, ProcessManagers, and Projections, and is not yet supported for standalone commanders, reactors, or subscribers.

server/src/main/java/io/spine/server/trace · high confidence

A new \StandardRejection\ interface has been added to the \io.spine.server.entity.rejection\ package to serve as a common contract for standard rejections during entity lifecycle routing. This interface extends \RejectionMessage\ and provides a \getEntityId()\ method to retrieve the packed ID of the entity that caused the rejection, along with a default \entityId()\ method for unpacking it. The package also includes updated metadata annotations (\@CheckReturnValue\, \@NullMarked\) to improve null-safety and return-value checking for developers using these rejection types.

server/src/main/java/io/spine/server/entity/rejection · high confidence

The server now includes a dedicated System Bounded Context for monitoring, auditing, and debugging domain entities. This context provides a \SystemClient\ API that exposes a \SystemWriteSide\ for posting system events (with optional parallel posting) and a \SystemReadSide\ for registering event dispatchers. Key components include a \CommandLogProjection\ that tracks the full lifecycle of commands (received, scheduled, dispatched, handled, errored, rejected) and a \ScheduledCommand\ projection for managing command scheduling. The system uses a \SystemEnricher\ to attach command details to scheduled events and supports configuration via \SystemFeatures\ to enable or disable command logging and event persistence.

server/src/main/java/io/spine/system/server · high confidence

The server now exposes a \TenantAdded\ event in the \spine.server.tenant\ package, signaling when a new tenant is added to a multi-tenant application (this event is not fired in single-tenant systems). Additionally, an internal \Tenant\ message has been defined to store basic tenant information, such as the tenant ID and creation timestamp, within the default \TenantIndex\.

server/src/main/proto/spine/server/tenant · high confidence

The \io.spine.server.tuple\ package now supports \Either\ values, allowing tuple elements to represent one of several possible message types (via \EitherOf2\ through \EitherOf5\). Additionally, tuple elements can now be optional, enabling nullable values in \Pair\, \Triplet\, \Quartet\, and \Quintet\ through new factory methods like \withNullable\ and \withOptional\. The \Element\ class manages these new types, and \IndexOf\ provides named constants for element positions.

server/src/main/java/io/spine/server/tuple · high confidence

The server module adds an \AbstractServiceBuilder\ class to provide a common base for building services that serve multiple bounded contexts. This new component simplifies the management of bounded contexts by offering methods to add, remove, and check for the presence of contexts, as well as building the final service instance. The \CommandService\ now extends this builder, allowing it to manage multiple bounded contexts and ensuring that warnings are logged if no contexts are added. This change enhances the flexibility and usability of the server-side architecture by centralizing context management logic.

server/src/main/java/io/spine/server · high confidence

Adds the protocol buffer definitions for the server-side catch-up mechanism, including the \CatchUp\ message to track process state (such as \IN\_PROGRESS\ and \FINALIZING\), the \CatchUpId\, and a set of internal events (\CatchUpRequested\, \HistoryEventsRecalled\, \CatchUpCompleted\, etc.) that signal the progression of historical event replay to projections.

server/src/main/proto/spine/server/catchup · high confidence

The \server-otel\ module now provides an OpenTelemetry-based tracer that records signal handling as spans, enabling distributed tracing for Spine server applications. The API is marked as experimental and requires explicit opt-in via the \@ExperimentalOtelTracing\ annotation. The implementation maps Spine signals to OpenTelemetry spans, deriving deterministic trace and span IDs from root signal IDs to ensure that all events within a causal chain appear under a single trace. The \OtelTracerFactory\ allows users to configure the underlying \OpenTelemetry\ instance and instrumentation scope, while \SignalSpan\ and \SpanAttribute\ handle the recording of span details and Spine-specific attributes (such as bounded context, tenant, and entity ID).

server-otel/src/main · high confidence

The \io.spine.server.procman\ package now includes \ProcessManagerMigration\, an abstract class that extends the generic \Migration\ framework to support migrations specifically for Process Manager instances. This new API allows users to define and apply migrations to Process Manager state, with the implementation handling transaction start via \PmTransaction\. The API is marked as \@Experimental\, indicating it is subject to change.

server/src/main/java/io/spine/server/procman · high confidence

The server now includes an in-memory implementation of the record storage layer (\InMemoryRecordStorage\), enabling lightweight, non-persistent data handling primarily for testing scenarios. This new component supports multitenancy by isolating data per tenant via \MultitenantStorage\, and provides full query capabilities including filtering, sorting (\RecordComparator\), field masking, and pagination limits through \TenantRecords\. A corresponding \InMemoryStorageFactory\ allows the system to instantiate these storages, while \StorageSpec\ defines the configuration context for each storage instance.

server/src/main/java/io/spine/server/storage/memory · high confidence

The \io.spine.server.projection.model\ package now provides model classes, starting with \ProjectionClass\, which expose type information about projection classes. This includes methods to retrieve event and state classes (domestic and external) and to find subscriber methods for specific events, enabling the framework to properly inspect and route events and state changes for projections.

server/src/main/java/io/spine/server/projection/model · high confidence

A new \io.spine.server.entity.model\ package has been added to the server module, providing the core model classes and interfaces for entity handling. This includes \EntityClass\ for managing entity metadata and factories, \StateClass\ for representing entity state types, \AssigneeEntityClass\ for entities handling commands, and \AbstractEntityFactory\ as a base for entity creation. These classes support the server's entity lifecycle, including visibility, ID management, and command routing.

server/src/main/java/io/spine/server/entity/model · high confidence

The \io.spine.server.transport\ package now provides a dedicated abstraction for inter-component messaging, introducing \TransportFactory\ to create \Publisher\ and \Subscriber\ channels. These channels are managed by \PublisherHub\ and \SubscriberHub\, which handle channel lifecycle, creation, and stale channel cleanup. The \MessageChannel\ interface defines channel identity and staleness, while \Subscriber\ manages \StreamObserver\ connections for receiving updates. Additionally, a \Statuses\ utility is included to convert \MessageError\ instances into gRPC \StatusRuntimeException\s.

server/src/main/java/io/spine/server/transport · high confidence

The server now includes a new \io.spine.system.server.event\ package that defines the structural foundation for system-level lifecycle events. This adds \SignalDispatchedMixin\ as a generic base for tracking dispatched signals, with specific implementations \CommandDispatchedMixin\ and \EventDispatchedMixin\ to distinguish between command and event dispatches. Additionally, \EntityLifecycleEvent\ is introduced as a common base for entity lifecycle events, providing a standardized \entityType()\ accessor. These interfaces enable the server to uniformly expose metadata about which entity class and signal type were involved in system operations.

server/src/main/java/io/spine/system/server/event · high confidence

The \io.spine.server.tenant\ package now provides the core infrastructure for multi-tenancy, introducing \CurrentTenant\ to manage the active tenant ID via thread-local storage and \TenantAwareOperation\/\TenantAwareFunction\ to ensure code executes within the correct tenant context. This change adds specific operation types for handling commands (\ActorRequestOperation\), events (\EventOperation\), queries (\QueryOperation\), and subscriptions (\SubscriptionOperation\), while \TenantAwareRunner\ offers a convenience API to execute arbitrary logic for a specific tenant. The package also includes \TenantIndex\ and \TenantStorage\ to manage tenant registration and a \SingleTenantIndex\ for single-tenant environments.

server/src/main/java/io/spine/server/tenant · high confidence

The core module adds foundational support for a unified signal model and bounded context management. New annotation interfaces (\AcceptsContracts\, \AcceptsExternal\, \AcceptsFilters\) define capabilities for receptor annotations, while \BoundedContext\ and \BoundedContextNames\ establish package-level context grouping and validation. The signal hierarchy is introduced via \Signal\, \SignalId\, and \SignalContext\ interfaces, implemented by new mixin classes (\CommandMixin\, \EventMixin\, \CommandContextMixin\, \EventContextMixin\, etc.) that provide access to actor context, timestamps, and root message IDs. Utility classes \Acks\, \Commands\, and \Enrichments\ handle command ID extraction, sorting, and enrichment management (clearing/finding), and new field classes (\EventField\, \EventContextField\) enable field-based subscription filtering.

core/src/main/java · high confidence

The \io.spine.server.route\ package now includes the \@Route\ annotation, which allows developers to annotate static methods on Entity classes to define custom message routing logic. When applied, the Spine Compiler generates implementation classes for the \RoutingSetup\ interface, enabling repositories to configure specific routing schemas for events and commands based on the annotated methods' signatures and return types.

server/src/main/java/io/spine/server/route · high confidence

A new \StorageGroup\ data class has been added to the server storage layer to ensure that different logical storages (such as entity history and event logs) are mapped to distinct physical storage locations (e.g., separate tables or kinds). This change introduces factory methods to create groups based on entity state classes or Bounded Context names, enforcing a collision-free mapping contract for storage vendors so that records of the same type but different logical purposes do not conflate in the underlying database.

server/src/main/kotlin/io/spine/server/storage · high confidence

This change introduces several Kotlin-specific convenience extensions in the \io.spine.server\ package to improve the developer experience. It adds \BoundedContextBuilder.add(KClass)\ and \BoundedContext.hasEntitiesOfType\/\hasEntitiesWithState\ extensions, allowing users to register entity classes and query context contents using Kotlin reified types without explicit Java class literals. It also restores the \under\<E\>\ configuration DSL for \ServerEnvironment\, enabling cleaner, type-safe environment-specific configuration blocks. Additionally, a new \DefaultRepository\ interface with a static \of\ factory method is provided to simplify the creation of default repositories for aggregates, process managers, and projections based on entity class types.

server/src/main/kotlin/io/spine/server · high confidence

Two new Kotlin annotations have been added to the core module to improve developer experience and reduce escaping issues in documentation. The \@ContractFor\ annotation marks abstract handler methods as 'contracts', allowing developers to define base classes for handlers with protected access modifiers while maintaining runtime discrimination from standard signal handlers. The \@Where\ annotation enables field-based filtering on handler method parameters, allowing events to be delivered only when specific field values match, with validation ensuring all filters in a class target the same field.

core/src/main/kotlin · high confidence

Added \MessageIdExtensions.kt\ in the server bus module, providing Kotlin extension functions to simplify creating acknowledgements. Users can now use \acknowledge()\ to return an OK status, \causedError()\ to reject a message due to an error (visible for testing), and \reject()\ on both \CommandId\ and \Command\ instances to handle rejections via events or throwables.

server/src/main/kotlin/io/spine/server/bus · high confidence

The server now exposes a Kotlin-native query interface in the \io.spine.server.query\ package, allowing users to retrieve entity view states more idiomatically. The new \Querying\ interface provides a \select()\ extension function for Kotlin users (avoiding the need to pass \Class\ objects explicitly) and a \select(Class)\ overload for Java compatibility. The accompanying \QueryingClient\ class offers \findById()\ to retrieve a single entity state by ID (returning null if not found) and \all()\ to retrieve all entities of a specific type. Legacy methods \find()\ and \withId()\ are deprecated in favor of \findById()\. This change simplifies querying logic for Kotlin developers while maintaining backward compatibility for Java users.

server/src/main/kotlin/io/spine/server/query · high confidence

This change introduces the Protobuf schema definitions for the server's message delivery and inbox subsystems. It adds \delivery.proto\ and \inbox.proto\ to define core types such as \ShardIndex\, \ShardSessionRecord\, \WorkerId\, and \InboxMessage\, including the new \InboxMessageStatus\ enum to track message delivery states (e.g., \TO\_DELIVER\, \DELIVERED\). It also adds \delivery\_events.proto\ to define events like \ShardProcessingRequested\ and \ShardProcessed\ for tracking shard processing lifecycle. Additionally, \node\_id.proto\ is added to define the \NodeId\ message used to identify application nodes. These definitions establish the data structures and events required for the new sharded delivery and inbox mechanisms.

server/src/main/proto/spine/server/delivery · high confidence

A new abstract base class, SingleCommandAssignee, has been added to the server command package to simplify the creation of assignees that handle exactly one command type. This class enforces at initialization that the derived class handles only a single command, throwing an error immediately if multiple command handlers are detected, which helps catch configuration mistakes early during development.

server/src/main/kotlin/io/spine/server/command · high confidence

This change introduces the core Protobuf contracts for the client module, defining the \CommandService\ for posting commands, the \QueryService\ for reading data with filtering and ordering, and the \SubscriptionService\ for subscribing to entity state and event updates. It establishes the \Query\ and \Topic\ message structures, including \Target\ and \TargetFilters\ for specifying criteria, \OrderBy\ for result sorting, and \SubscriptionUpdate\ for delivering changes, along with supporting types like \EntityStateWithVersion\ and \ActorContext\.

client/src/main/proto · high confidence

The client library introduces a structured request model with \ActorRequestFactory\ to create commands, queries, and topics based on actor context, tenant, and time zone. \ClientRequest\ and its base class provide a fluent API for posting commands with optional event observation and custom error handling. A new typed filter hierarchy (\EntityStateFilter\, \EventFilter\, \CompositeFilter\) allows filtering subscriptions by entity state and event context, with composite filters supporting conjunction and disjunction logic.

client/src/main/java/io/spine/client · high confidence

The \io.spine.server.dispatch\ package now includes a suite of new classes to manage and inspect dispatch outcomes. \DispatchOutcomeHandler\ provides a fluent API for configuring specific callbacks for success, error, interruption, and rejection scenarios, including handlers for produced commands and events. \DispatchOutcomes\ offers static factory methods to create outcome instances for various dispatch scenarios, such as successful message dispatch, inbox delivery, and remote publishing. Additionally, several mixin interfaces (e.g., \DispatchOutcomeMixin\, \SuccessMixin\, \ProducedEventsMixin\) have been added to these message types to support validation and field access via the \FieldAwareMessage\ contract.

server/src/main/java/io/spine/server/dispatch · high confidence

The \dispatching.proto\ file introduces the core message types for the server's dispatching subsystem, defining how batch signal propagation results are reported. It adds \BatchDispatchOutcome\ to aggregate results for multiple signals and \DispatchOutcome\ to detail the result of individual signal handling, including success, errors, interruptions, ignored signals, and inbox/remote delivery status. The schema also defines \Success\, \ProducedEvents\, and \ProducedCommands\ to capture the outputs of signal handlers, explicitly allowing empty produced events or commands to support handlers that return optional values.

server/src/main/proto/spine/server/dispatch · high confidence

The framework now provides dedicated storage for entity events and state history. EntityEventStorage journals emitted events for traceability, exposing entity ID, creation time, and version for querying. EntityStateHistoryStorage retains recent entity states, enabling time-based lookups (stateAt) and efficient trimming without loading full payloads. Both storages share a common column structure (entity\_id, created, version) and are identified by the entity class, allowing applications to query and manage event and state histories consistently.

server/src/main/kotlin/io/spine/server/entity/storage · high confidence

The server's entity subsystem now includes new classes to manage entity creation, event filtering, and transaction monitoring. \DefaultEntityFactory\ and \EntityFactory\ provide a standardized way to instantiate entities, while \CompositeEventFilter\ allows chaining multiple event filters. \BatchDispatch\ handles the propagation of multiple events within a transaction, and \EntityLifecycleMonitor\ tracks transaction phases to trigger lifecycle callbacks. \EntityIdFunction\ and \EntityIterator\ support ID transformation and entity enumeration, respectively. These changes refine how entities are created, filtered, and monitored during their lifecycle.

server/src/main/java/io/spine/server/entity · high confidence

The server entity module now includes core protocol definitions for managing entity state and lifecycle. \entity.proto\ introduces \EntityRecord\ to carry entity ID, state, version, and new \LifecycleFlags\ (supporting \archived\ and \deleted\ states), along with \EntityRecordChange\ for state diffs and \EntityStateValidationError\ for technical validation errors. \standard\_rejections.proto\ defines specific rejection types (\CannotModifyArchivedEntity\, \CannotModifyDeletedEntity\, \EntityAlreadyArchived\, \EntityAlreadyDeleted\) to handle business rule violations when modifying entities based on their lifecycle status. \state\_key.proto\ adds \EntityStateKey\ to uniquely identify an entity's state by its ID and version, serving as the key for state history storage.

server/src/main/proto/spine/server/entity · high confidence

The server module introduces three new Protobuf definitions to enhance event handling capabilities. The \EventFilter\ message allows filtering events by type, aggregate ID, and specific field values within both the event data and its context. The \EventStreamQuery\ message defines how to query the event store, supporting time-based range filtering (before/after timestamps), the application of \EventFilter\ rules, and a configurable \Limit\ to cap the number of returned events. Additionally, a new \NoReaction\ standard event type is added, which the framework treats specially by never storing or processing it, intended for cases where message processing produces no output.

server/src/main/proto/spine/server/event · high confidence

The server module introduces a new event handling architecture in the \io.spine.server.event\ package, providing distinct base classes for event producers and consumers. \AbstractEventReactor\ serves as the foundation for components that react to events and produce new ones, while \AbstractEventSubscriber\ handles incoming events without producing outputs. Stateful reactors are supported via \AbstractStatefulReactor\, which integrates with the delivery inbox system to manage state transitions. The \EventBus\ now utilizes \EventDispatcher\ and \EventDispatcherDelegate\ interfaces to route events, with \EventDispatcherRegistry\ enforcing strict separation between domestic and external event types. Additionally, \DeadEventTap\ captures unhandled events for storage, and \EventEnricher\ allows post-storage enrichment before dispatch.

server/src/main/java/io/spine/server/event · high confidence

A new Kotlin extension function \actorRequestFactory\ has been added to the client library, allowing users to easily create a new \ActorRequestFactory\ instance by passing a \UserId\. This simplifies the boilerplate required to initialize request factories with a specific actor identity.

client/src/main/kotlin · high confidence

The client module now includes a set of new helper classes for managing gRPC stream observers. Users can create no-op observers or observers that forward only errors via the StreamObservers utility. A new CompositeObserver allows delegating stream events to multiple observers, while DelegatingObserver provides a base class for custom delegation. MemoizingObserver captures streamed responses and errors for later inspection. Additionally, StreamObservers.fromStreamError enables extracting system errors from gRPC StatusRuntimeExceptions and StatusExceptions by parsing trailer metadata.

client/src/main/java/io/spine/grpc · high confidence

The server now includes an in-memory implementation of the sharded work registry (\InMemoryShardedWorkRegistry\) within the \io.spine.server.delivery.memory\ package. This component manages shard processing sessions using a concurrent map, synchronizes access to ensure thread safety, and identifies workers by the current thread ID. It supports picking up shards, releasing sessions, and clearing expired sessions based on an inactivity period, providing a concrete backend for the delivery subsystem's work distribution logic.

server/src/main/java/io/spine/server/delivery/memory · high confidence

The \io.spine.server.transport.memory\ package now includes \InMemoryPublisher\, \InMemorySubscriber\, and \InMemoryTransportFactory\ to provide a synchronous, in-memory message transport for use within the same JVM. Additionally, \SingleThreadInMemSubscriber\ and \SingleThreadInMemTransportFactory\ are introduced to deliver messages sequentially on a single thread, supporting scenarios that require strict ordering or single-shard-per-aggregate testing. These components are explicitly intended for test environments only.

server/src/main/java/io/spine/server/transport/memory · high confidence

The server now includes an IntegrationBroker that enables Bounded Contexts to exchange external domain events via a shared transport. This change introduces a new set of components in the integration package: the IntegrationBroker acts as the central coordinator, using BusAdapter to bridge local event buses with the transport, and specialized exchanges (ConfigExchange, EventsExchange, StatusExchange) to manage subscriptions, event routing, and online status. Domestic events are published to remote contexts via DomesticEventPublisher, while incoming external events are handled by IncomingEventObserver and dispatched to local subscribers. The system uses ExternalMessage wrappers and ExternalEventsWanted configuration messages to dynamically adjust event subscriptions between contexts.

server/src/main/java/io/spine/server/integration · high confidence

The projection subsystem now includes dedicated classes to manage the catch-up phase and state migrations. CatchUpEndpoint handles the special CatchUpStarted event by deleting existing projection state before replaying historical events, ensuring a clean slate for recovery. Additionally, ProjectionMigration and ProjectionTransaction provide the underlying transactional mechanics and migration support for projection instances, allowing them to safely evolve their state schemas.

server/src/main/java/io/spine/server/projection · high confidence

The \server-testlib\ module introduces a comprehensive set of classes to support integration testing of Spine Bounded Contexts. This includes the \BlackBox\ class and its \ContextAwareTest\ base, which allow tests to send commands and events to a context and assert on the resulting state and emitted messages. The library provides \CommandSubject\ and \EventSubject\ for fluent assertions on generated signals, \Assertions\ for verifying command and event classes, and \TestEventFactory\ for creating test events with specific timestamps. Additionally, \ClientFactory\ and \BlackBoxClients\ manage in-process gRPC connections for test clients, while \NoOpLifecycle\ and \BlackBoxSetup\ handle lifecycle and setup details for the test environment.

server-testlib/src/main/java · high confidence

The \io.spine.server.procman.migration\ package now provides four standard migration operations for Process Managers: \MarkPmArchived\ to set the archived flag, \MarkPmDeleted\ to set the deleted flag, \RemovePmFromStorage\ to physically delete the entity record, and \UpdatePmState\ to re-execute \onBeforeCommit()\ logic for state recalculation. These classes, marked as experimental, allow users to apply these specific state changes or updates to existing Process Manager instances via the repository's migration API.

server/src/main/java/io/spine/server/procman/migration · high confidence

The \io.spine.server.projection.migration\ package now includes four new standard migration classes: \MarkProjectionArchived\ to set the archived flag, \MarkProjectionDeleted\ to set the deleted flag, \RemoveProjectionFromStorage\ to physically delete the projection record, and \UpdateProjectionState\ to re-run \onBeforeCommit()\ logic for state recalculation. These operations allow users to manage projection lifecycle states and update calculated fields via \RecordBasedRepository.applyMigration\.

server/src/main/java/io/spine/server/projection/migration · high confidence

The Stand component now includes a comprehensive set of internal classes to manage entity subscriptions, event handling, and queries. This introduces dedicated handlers for entity lifecycle events (changes, archival, deletion, restoration, unarchival) and event subscriptions, along with an in-memory type and event registry to track available types and producers. A new query processor enables querying entity states, while a multitenant subscription registry manages subscription slices per tenant. These changes provide the underlying mechanism for Stand to subscribe to and process entity and event updates, as well as execute queries against registered repositories.

server/src/main/java/io/spine/server/stand · high confidence

The server now exposes a comprehensive set of new Protobuf definitions in \spine.system.server\ to track system internals. This includes a \CommandLog\ projection and associated events (e.g., \CommandReceived\, \CommandHandled\, \CommandErrored\) to monitor the full lifecycle of commands through the command bus. Additionally, new \EntityLog\ events (such as \EntityCreated\, \EntityStateChanged\, and \EventDispatchedToSubscriber\) provide visibility into entity state changes and event distribution. The update also introduces diagnostic events like \ConstraintViolated\ and \HandlerFailedUnexpectedly\ for error tracking, alongside definitions for scheduled commands and mirror projections.

server/src/main/proto/spine/system · high confidence

Added two new shell scripts to the \scripts\ directory. \report-coverage.sh\ automates the download of the Codacy coverage reporter and submits JaCoCo XML reports to Codacy, replacing previous manual or embedded steps. \request-package-names.sh\ queries the GitHub API to retrieve a list of Maven package names published from a specific repository, outputting the results as a JSON array to a specified file.

scripts · high confidence

A new test fixture, StockKeeper, demonstrates the use of tryAlter for preventive state validation within a ProcessManager. This allows the system to check entity constraints (such as preventing negative stock levels) before applying changes, ensuring that invalid states are rejected without emitting side-effect events.

server/src/testFixtures/kotlin/io/spine/server/entity · high confidence

The repository is initialized with essential configuration files and scripts to support the build system and development workflow. This includes a \.codecov.yml\ to configure code coverage reporting (ignoring generated and test files, disabling patch status), a \.gitattributes\ file to enforce consistent line endings across different operating systems, and a \.gitmodules\ file to register the \config\ and \.agents/shared\ submodules. Additionally, a \pull\ script is added to update the \config\ submodule, and an \init-submodules\ script is provided to bootstrap submodules in fresh worktrees. A \version.gradle.kts\ file is introduced to centrally define the library version as \2.0.0-SNAPSHOT.551\. The \.gitignore\ is also updated to exclude build artifacts and IDE files.

(repo-wide) · high confidence

A change to existing behaviour in buildSrc — 1 commit, 1 file.

buildSrc · low confidence · unverified

The \io.spine.server.entity.status\ and \io.spine.server.integration.grpc\ packages now include \package-info.java\ files that apply JSpecify annotations (\@NullMarked\) and Error Prone annotations (\@CheckReturnValue\). This change introduces compile-time null-safety checks and return-value usage warnings for code within these specific server modules, helping to prevent null-pointer exceptions and unused return values.

server/src/main/java/io/spine/server/entity/status, server/src/main/java/io/spine/server/integration/grpc · high confidence

The \.agents\ directory has been restructured to use symbolic links that redirect to shared locations. Specifically, \guidelines\, \scripts\, and \skills\ now point to the \shared\ directory, while \project.md\ points to \../docs/project.md\. This change centralizes agent configuration and documentation, ensuring that updates to these shared resources are immediately reflected in the agent's context without duplicating content.

.agents · high confidence

The core aggregate management components in \server/src/main/kotlin/io/spine/server/aggregate\—including the \Aggregate\ base class, \AggregateRepository\, transaction handling (\AggregateTransaction\), and dispatch endpoints (\AggregateCommandEndpoint\, \AggregateEventReactionEndpoint\)—have been converted from Java to Kotlin. This migration consolidates the dispatch path and repository logic into the Kotlin codebase, ensuring consistent implementation of command handling, event reaction, and state persistence for aggregates.

server/src/main/kotlin/io/spine/server/aggregate · high confidence

The \io.spine.server.aggregate.model\ package has been restructured to support a direct-state mutation model, removing the legacy event sourcing pattern. \AggregateClass\ now enforces that \@Apply\ methods are not used, requiring state changes to be handled directly in \@Assign\ or \@React\ receptors. The package introduces new model classes including \AggregatePartClass\ (now deprecated in favor of ProcessManagers), \Applier\, and \PartFactory\ to manage aggregate metadata and creation. Additionally, the model now exposes detailed event routing information, distinguishing between domestic and external events and consolidating outgoing events, including rejections, into a single \outgoingEvents\ view.

server/src/main/java/io/spine/server/aggregate/model · high confidence

The server now loads routing setup classes (CommandRoutingSetup, EventRoutingSetup, and StateRoutingSetup) asynchronously using Kotlin coroutines and the ServiceLoader. This change moves the initialization of the RoutingSetupRegistry to a background process, allowing the application to start faster by not blocking the main thread while scanning for generated routing implementations.

server/src/main/kotlin/io/spine/server/route/setup · high confidence

The CommandBus now provides detailed visibility into command processing through new system events and observers. A CommandReceivedTap filter posts a CommandReceived system event whenever a command enters the bus, while a CommandAckMonitor observes command outcomes, posting CommandAcknowledged, CommandErrored, or CommandRejected system events based on the final status. Additionally, an AckRejectionPublisher ensures that business rule rejections are published to the EventBus, allowing subscribers to react to them. The bus also includes a CommandScheduler for handling delayed commands and a CommandValidator to enforce tenant ID and message constraints before processing.

server/src/main/java/io/spine/server/commandbus · high confidence

In the server model package, \NothingHappened\ and \NoReaction\ are deprecated in favor of \NoReaction\ from \io.spine.server.event\ to resolve naming collisions with Kotlin's \Nothing\ type. Additionally, a new \MethodExts.kt\ file provides a \reference()\ extension function that generates diagnostic strings for Java reflection methods, improving error reporting for receptor declarations.

server/src/main/kotlin/io/spine/server/model · high confidence

The \AggregateRoot\, \AggregatePartRepository\, and \AggregateRootDirectory\ classes in the \io.spine.server.aggregate\ package are now deprecated because they do not provide isolation for invariants; users should use \ProcessManager\ to coordinate multiple aggregates instead. Additionally, the \@Apply\ annotation is deprecated as event sourcing has been removed from aggregates; aggregates now mutate state directly in \@Assign\ or \@React\ receptors and load from their latest persisted state rather than replaying events. The \@Apply\ annotation is retained only to detect classes that still use it, which will fail fast at model-building time.

server/src/main/java/io/spine/server/aggregate · high confidence

The \aggregate.proto\ definitions for \Snapshot\, \AggregateEventRecordId\, \AggregateEventRecord\, and \AggregateHistory\ are now marked as deprecated. These messages are retained solely for wire compatibility with pre-cutover journal data; the runtime no longer produces or reads them, as event-sourced loading has been removed and the journal now stores plain \spine.core.Event\s directly.

server/src/main/proto/spine/server/aggregate · high confidence

The \DoNothing\ command and \Nothing\ event types, previously defined in \spine.server.model\, are now deprecated. These types are no longer the recommended approach for handling no-action scenarios; users should migrate to \spine.server.command.DoNothing\ and \spine.server.event.NoReaction\ respectively. The framework continues to treat these deprecated types specially (not posting, storing, or applying them), but they are marked for removal in favor of the new standard locations.

server/src/main/proto/spine/server/model · high confidence

The core entity dispatch path and history management in \server/src/main/kotlin/io/spine/server/entity\ have been rewritten in Kotlin. This migration introduces \SignalDispatchingEntity\ as the central dispatching base class, consolidates history loading via \HistoryLoader\ and \RecentEventHistory\ for efficient recent-event reads, and adds a \DoubleDispatchGuard\ to prevent duplicate command/event processing within a batch. Repository-side state history recording is now opt-in and appended per dispatch, while internal dispatch phases (\CommandDispatchingPhase\, \EventDispatchingPhase\) and converters (\DefaultConverter\) are simplified and restricted to internal visibility.

server/src/main/kotlin/io/spine/server/entity · high confidence

The event handling API in \io.spine.server.event\ now includes a new \Reaction\ abstract class, allowing developers to define handlers that convert an incoming event directly into zero or more output events without an intermediate command step. To support this, a new \Just\<E\>\ tuple class has been added to represent a single event, replacing the deprecated \NothingHappened\ with \NoReaction\ for indicating no output. Additionally, extension functions (\just()\, \asA()\, \asB()\) have been added to \EventMessage\ to simplify wrapping events into these new tuple types, and the \Policy\ class has been updated to clarify its role in producing commands.

server/src/main/kotlin/io/spine/server/event · high confidence

The \io.spine.server.event.storage\ package now includes a \package-info.java\ file that applies JSpecify null-safety annotations. Specifically, the package is marked with \@NullMarked\ and \@CheckReturnValue\, establishing stricter null-handling contracts and return-value checks for all classes and interfaces within this event storage component.

server/src/main/java/io/spine/server/event/storage · high confidence

The test fixture aggregates and repositories in the switchman context (Log, Switchman, and SwitchmanBureau) have been rewritten from Java to Kotlin. This change updates the internal implementation of these test components to use Kotlin syntax and idioms, while preserving their existing behavior for routing commands and handling events in the test environment.

server/src/testFixtures/kotlin/io/spine/server/given/context/switchman · high confidence

The buildSrc module has been restructured with a comprehensive set of new Kotlin source files and Gradle plugins to standardize the build process. This includes a new dependency resolution strategy that enforces versions via BOMs and explicit forcing, new plugin scripts for Dokka documentation generation (including KMP support and custom styling), Detekt code analysis, and a ConfigTester for validating local changes against dependent repositories. Additionally, centralized objects for build settings (Java 17 target), documentation, and license management have been introduced to replace ad-hoc configurations.

buildSrc/src · high confidence

The server-side command processing model has been restructured with new core abstractions. Non-aggregate classes can now handle commands via the \@Assign\ annotation and the \AbstractAssignee\ base class, which automatically posts resulting events to the \EventBus\. Command transformation and reaction capabilities are provided by the \@Command\ annotation and the \AbstractCommander\ base class, allowing methods to convert incoming commands or events into new commands posted to the \CommandBus\. The framework now uses \DispatchOutcome\ to manage the results of these operations, including handling rejections and errors by posting system events.

server/src/main/java/io/spine/server/command · high confidence

The \io.spine.server.enrich\ package has been replaced with a new, generic enrichment system. Users can now define enrichment functions via the \EnricherBuilder\, which supports registering multiple enrichment functions per message type and enforces uniqueness to prevent duplicates. The \Enricher\ applies these functions after messages are stored and before they are dispatched, utilizing a \Schema\ that automatically aggregates multiple functions into a \CompositeFn\ or uses a \SingularFn\ for single functions. A specialized \EventEnrichmentFn\ interface is provided for event-specific enrichment logic.

server/src/main/java/io/spine/server/enrich · high confidence

The core Process Manager machinery—including the repository, command and event endpoints, transaction handling, and the base entity class—has been rewritten in Kotlin. This migration consolidates the dispatch and persistence logic for process managers into a single, idiomatic Kotlin codebase, ensuring consistent behavior for command handling, event reacting, and state management within the server.

server/src/main/kotlin/io/spine/server/procman · high confidence

The \ProcessManagerClass\ model now distinguishes between domestic and external events via new \domesticEvents()\ and \externalEvents()\ methods, ensuring that event dispatching treats these categories correctly. It also exposes all messages produced by the process manager—events, commands, and rejections—through \outgoingEvents()\, \outgoingCommands()\, and related query methods, allowing users to inspect exactly what a ProcessManager class emits in response to incoming signals.

server/src/main/java/io/spine/server/procman/model · high confidence

The core projection components in the server module, including the \Projection\ base class, \ProjectionRepository\, \DefaultProjectionRepository\, and \ProjectionEndpoint\, have been rewritten from Java to Kotlin. This migration updates the internal implementation of how projections are stored, dispatched, and caught up, while preserving the existing public API and behavioral contract for managing event-driven data views.

server/src/main/kotlin/io/spine/server/projection · high confidence

The core protocol definitions have been restructured to refine the domain model and improve type safety. Key changes include renaming \BoundedContextId\ to \BoundedContextName\ to better reflect its semantic role, and replacing the generic \MessageId\ with specific \CommandId\ and \EventId\ types to distinguish between command and event identifiers. The \ActorContext\ has been updated to replace the deprecated \zone\_offset\ with a \zone\_id\ for time-zone information. Additionally, the \EventContext\ now uses a unified \Origin\ message to track the message chain, deprecating the previous \command\_context\ and \event\_context\ fields, and the \Response\ status now explicitly supports \rejection\ events alongside standard errors and success states.

core/src/main/proto · high confidence

The entity storage layer has been restructured to persist and query entities via \EntityRecord\ rather than raw state messages. This introduces \EntityRecordColumn\ to define lifecycle columns (archived, deleted, version) and \SpecScanner\ to automatically generate storage specifications from entity classes. Querying is now mediated by \ToEntityRecordQuery\, which translates \EntityQuery\ calls into \RecordQuery\ operations, and \AsEntityRecordColumn\ adapts generic column types for use with records. Storage operations are handled by \EntityRecordStorage\, which delegates to the underlying record storage while filtering for active records by default.

server/src/main/java/io/spine/server/entity/storage · high confidence

The event store implementation has been restructured to group storage by Bounded Context, ensuring that events for different contexts are persisted in separate physical storage units (such as distinct tables). The default store now leverages the new \RecordSpec\ and \RecordColumn\ APIs for column definitions and utilizes the updated \io.spine.query\ API for converting and executing event stream queries, including support for time bounds, type filtering, and limits.

server/src/main/java/io/spine/server/event/store · high confidence

The integration broker protocol has been restructured to better reflect real-world usage, including renaming the \IntegrationEventBroker\ to \IntegrationBroker\ and introducing new messages such as \ExternalEventsWanted\, \ExternalEventType\, and \BoundedContextOnline\ to manage external event subscriptions and context connectivity. A significant behavioral change occurs in the \ExternalMessage\ structure: the \actor\_context\ field has been removed because it could not be meaningfully populated across the variety of external message types, simplifying the message contract for cross-boundary communication.

server/src/main/proto/spine/server/integration · high confidence

The \io.spine.server.type\ package has been restructured to provide a cleaner, more consistent API for handling server-side message types. This change introduces a new \MessageEnvelope\ interface and an \AbstractMessageEnvelope\ base class to standardize how commands and events are wrapped and accessed. Specific implementations like \CommandEnvelope\ and \EventEnvelope\ now offer improved accessors for properties such as tenant ID, message class, and context. Additionally, new value objects like \CommandClass\ and \EventClass\ replace previous type-handling mechanisms, with \EventClass\ now supporting rejection detection and empty set shortcuts. The refactoring also adds \SignalEnvelope\ for unified signal handling and \EnvelopeWithOrigin\ to track message provenance, simplifying how the server manages and inspects incoming and outgoing messages.

server/src/main/java/io/spine/server/type · high confidence

The command handling model in \io.spine.server.command.model\ has been restructured to use a new set of classes and interfaces for managing command receptors and signatures. This includes the introduction of \CommandReceptor\ as an abstract base for methods accepting commands, \CommandSubstituter\ for methods producing commands in response to incoming commands, and \CommandingReaction\ for methods producing commands in response to events. The \CommanderClass\ now integrates both command substitution and reaction handling via \EventReceivingClassDelegate\, while \AssigneeClass\ and \AssigneeReceptor\ handle command assignment. Signature classes like \CommandAcceptingSignature\, \CommandSubstituteSignature\, and \CommandReactionSignature\ define the allowed parameters and return types for these methods. Additionally, \DuplicateHandlerCheck\ ensures no duplicate command-handling methods exist across aggregates, process managers, assignees, and commanders.

server/src/main/java/io/spine/server/command/model · high confidence

The delivery subsystem has been restructured to support more robust message processing and projection catch-up. This change introduces a new \AbstractMessageEndpoint\ that standardizes dispatching by catching runtime exceptions and wrapping them in \DispatchOutcome\. A new \AbstractWorkRegistry\ manages shard session lifecycles, allowing workers to pick up shards and releasing expired sessions based on inactivity. The catch-up process is now driven by \CatchUpProcess\ and \CatchUpProcessBuilder\, which handle historical event replay, manage a 'turbulence' period to transition from history to live events, and emit specific lifecycle events like \CatchUpStarted\ and \CatchUpCompleted\. Additionally, \BatchDeliveryListener\ allows for optimization when delivering batches of messages to the same target, and \CatchUpMessageComparator\ ensures proper ordering of catch-up related events.

server/src/main/java/io/spine/server/delivery · high confidence

The event handling model in the server module has been refactored to use a new set of classes and interfaces, including EventReactorClass, EventSubscriberClass, EventReactorMethod, and EventSubscriberMethod. This change introduces a more structured approach to handling events, with clear separation between event reactors and subscribers. The new model supports both domestic and external events, and provides better type safety and validation for event handling methods.

server/src/main/java/io/spine/server/event/model · high confidence

The server message bus has been restructured to introduce a pluggable \BusFilter\ chain and a dedicated \Listener\ mechanism. Messages posted to the bus are now intercepted by filters (such as the new \DeadMessageFilter\ for handling unregistered message types) and observed by listeners before dispatch. The underlying dispatcher registry and envelope validation logic have been refactored to support this new flow, changing how message acceptance, rejection, and delivery outcomes are managed internally.

server/src/main/java/io/spine/server/bus · high confidence

The storage implementation in \io.spine.server.storage\ has been restructured to improve query performance and API clarity. A new \ColumnMapping\ hierarchy (\AbstractColumnMapping\, \DefaultColumnMapping\) with a \KnownMappings\ cache optimizes the discovery of type-specific storage rules, addressing a identified performance hotspot. The \RecordSpec\ class now explicitly defines identifier extraction and column definitions for stored records, replacing previous ad-hoc configurations. Additionally, \DelegatingRecordStorage\ and \MessageStorage\ provide a standardized delegation pattern for various storage types, while \FieldMaskApplier\ and \QueryConverter\ enhance the precision and conversion of query operations.

server/src/main/java/io/spine/server/storage · high confidence

The RejectionEnvelope class in the server event model has been rewritten in Kotlin, replacing the previous Java implementation. This change maintains the existing behavior of wrapping an EventEnvelope to provide convenient access to rejection details, including the rejection message, the originating command, and the command context, while leveraging Kotlin's delegation features for cleaner code structure.

server/src/main/kotlin/io/spine/server/event/model · high confidence

The \HandlerLifecycle\ interface has been renamed to \ReceptorLifecycle\ within the server-side logging utilities. This change updates the callback mechanism for handler method invocations, where \beforeInvoke\ and \afterInvoke\ methods are now defined on the new \ReceptorLifecycle\ interface, affecting how subscribers implement lifecycle hooks for event handling.

server/src/main/java/io/spine/server/log · high confidence

The server's message handling model has been refactored to use the term 'Receptor' instead of 'Handler' (e.g., \AbstractReceptor\, \CommandReceptor\, \ReceptorLifecycle\). This change is accompanied by the introduction of specific model classes for different signal types, including \AggregateClass\, \ProcessManagerClass\, \ProjectionClass\, \CommandHandlerClass\, and \EventSubscriberClass\. The system now enforces stricter validation on handler signatures, such as preventing duplicate command handlers via \DuplicateCommandReceptorError\ and ensuring that command-accepting methods do not return rejection messages.

server/src/main/java/io/spine/server/model · high confidence

The \Security\ object in the server module has been rewritten from Java to Kotlin. This change implements the core access control mechanism that restricts method calls to classes within the Spine framework (\io.spine.server\), system server components (\io.spine.system.server\), and testing utilities (\io.spine.testing.server\). The Kotlin implementation utilizes \StackWalker\ to inspect the call stack and determine the calling class, throwing a \SecurityException\ if the caller is not from an allowed package.

server/src/main/kotlin/io/spine/server/security · high confidence

The server-side routing logic in the \io.spine.server.route\ package has been migrated from Java to Kotlin. This change introduces new routing strategies for events and commands, including the ability to route events by producer ID, by the first field of the message, or by a combination of both. Command routing now defaults to using the first field of the command message to determine the target entity. The migration also includes new interfaces and classes such as \CommandRouting\, \EventRouting\, and \MessageRouting\ to support these behaviors.

server/src/main/kotlin/io/spine/server/route · high confidence

The server's storage factory now detects when a Bounded Context is configured not to store events and, in that case, provides an empty event store instead of a real one. This ensures that system-level contexts that do not require event history do not incur the overhead of event storage, while all other storage creation continues to delegate to the underlying factory as before.

server/src/main/java/io/spine/server/storage/system · high confidence

Added BlackBox test utilities for server-side entity testing; Added CountingContext test fixture for query client specifications; Added Fizz Buzz test fixture protocol definitions; Added FizzBuzz test fixture for command routing; Added Kotlin test fixtures for the quiz process manager; Added Kotlin test suite for core module utilities and mixins; Added Kotlin test suite for server command and event routing; Added Kotlin test suites for Command and Commands classes; Added Kotlin test suites for Process Manager lifecycle, dispatching, and journaling; Added Kotlin test suites for projection repository behavior; Added Kotlin test suites for server entity components; Added Kotlin tests for DeliveryBuilder validation and configuration; Added Kotlin tests for server model receptors, filters, and signatures; Added comprehensive test coverage for CommandBus components; Added comprehensive test coverage for client query and filter components; Added comprehensive test coverage for the high-level Client API; Added end-to-end tests for projection scenarios; Added integration tests for event publishing and third-party context handling; Added server-side test domain models and schemas; Added test command definitions for CommandFactory tests; Added test coverage for CommandService, DefaultRepository, and Server components; Added test coverage for Stand query processing, validation, and multi-tenant isolation; Added test coverage for aggregate command handling, querying, and repository lifecycle; Added test coverage for aggregate state history and dispatch guards; Added test coverage for co-existing Bounded Contexts; Added test coverage for core event mixins, context, and enrichment utilities; Added test coverage for server components; Added test coverage for server event handling components; Added test coverage for server tuple types; Added test environment utilities for client module; Added test event definitions for client-side project events; Added test fixture for context sorting and routing; Added test fixture for interface-based event routing; Added test fixture for signature model events; Added test fixtures for aggregate and bus scenarios; Added test fixtures for client-side query operations; Added test fixtures for drawing context events and objects; Added test fixtures for process manager journaling and double-dispatch specs; Added test fixtures for user account password change scenarios; Added test infrastructure for aggregate state history; Added test protocol buffers for core module utilities; Added tests for BlackBoxSetup and UnsupportedCommandGuard; Added tests for EnricherBuilder and SingularFn; Added tests for EntityClass behavior; Added tests for MessageIdExtensions; Added tests for MirrorMigration and MirrorToEntityRecord; Added tests for ProcessManagerClass message handling; Added tests for ProcessManagerRepository lifecycle and behavior; Added tests for ProjectionClass event handling and validation; Added tests for QueryingClient; Added tests for Security class access restrictions; Added tests for SpecScanner column extraction; Added tests for StorageGroup creation logic; Added tests for SystemAwareStorageFactory; Added tests for TestActorRequestFactory; Added tests for \AbstractEntity\ logging behavior; Added tests for \Single\ tuple; Added tests for aggregate model classes and event appliers; Added tests for bus builder, filter, and synchronization logic; Added tests for command dispatching and assignee signature validation; Added tests for command model signature classification and handler behavior; Added tests for command routing rejection and state update routing; Added tests for core-testlib \Given\*\ utility classes; Added tests for dispatch mixins and outcome handling; Added tests for entity event and state history storage behaviors; Added tests for event reactor and subscriber model classes; Added tests for event store storage grouping by Bounded Context; Added tests for gRPC client observer utilities; Added tests for handler methods returning events via common interface; Added tests for in-memory transport components; Added tests for message tracing in the server; Added tests for projection column configuration, repository behavior, and state routing; Added tests for server entity subsystem components; Added tests for server model validation and handler registration; Added tests for server type system components; Added tests for server-side testing utilities and black-box integration fixtures; Added tests for storage column mapping and record specification; Added tests for system server components; Added tests for the gRPC TestClient; Added tests for the server delivery subsystem; Added unit tests for in-memory storage components; Added unit tests for tenant management components; Added unit tests for the OpenTelemetry tracing module; Added user context test fixtures for server-side testing; Client API test suite migrated to Kotlin; Migrated client factory tests to Kotlin; New Kotlin-based test support for aggregate command and event dispatching; New test fixture for user context event routing; New test fixtures for server security, client tasks, and aggregate testing; New test-fixture protocol definitions for Switchman context.

The project has been migrated to a Gradle-based build system, introducing \build.gradle.kts\ and \settings.gradle.kts\ files for the root \core-jvm\ project and its submodules (\core\, \client\, \server\, \server-otel\, and their test libraries). This setup defines the dependency graph for internal Spine SDK artifacts (such as \spine-base\, \spine-validation\, and \spine-logging\) and external libraries (including gRPC 1.83.1, Kotlin 2.4.10, and Jackson 2.18.3). The configuration also establishes publishing destinations to GitHub Packages and Cloud Artifact Registry, configures the Kotlin and gRPC compiler plugins, and sets up test fixtures and coverage reporting via Kover.

(dependencies) · high confidence

The Gradle wrapper has been updated to use Gradle distribution version 9.7.1. This change ensures that builds are executed using the specified Gradle version, providing consistency across development environments and leveraging any improvements or bug fixes included in this release.

gradle · high confidence

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 66.

• Code Health 99
• Architecture 99
• Maturity 69
• Readiness 64
• Security 57
• Domain Modelling 100

• 300 commits — 276 feature/other, 24 fixes

• server/src — 166 commits
• (repo) — 31 commits
• (root) — 23 commits
• docs/dependencies — 23 commits
• buildSrc/src — 15 commits
• .agents/tasks — 14 commits
• server-testlib/src — 8 commits
• client/src — 7 commits
• .agents/memory — 5 commits
• core/src — 4 commits
• .idea/inspectionProfiles — 1 commit
• client-testlib/src — 1 commit
• core-testlib/src — 1 commit
• server/build.gradle.kts — 1 commit

• fix: Annotate fields and fix deprecation message
• fix: Fix Javadoc language
• fix: Fix Javadoc language
• fix: Fix Javadoc language
• fix: Fix EntityEventStorage constructor call
• fix: Fix a comma splice in HistoryStorageIdentitySpec docs
• fix: Fix annotation
• fix: Fix content bugs in client module Javadoc
• fix: Fix content bugs in server module Javadoc/proto docs
• fix: Fix import statement for OverridingMethodsMustInvokeSuper annotation
• fix: Fix stale class-name reference in server-testlib Javadoc
• fix: Fix test reference to the record storage API seam
• fix: Fix the article in Javadoc
• fix: Fix the documentation flagged by the pre-PR review
• fix: Fix the name suppression to satisfy detekt too
• fix: Fix the parameter order in KDoc
• fix: Fix the routing method name in EventRouting docs
• fix: Fix type reference in Javadoc to match the actual contract of TypeRegistry
• fix: Fix which/that
• fix: Fix widow lines left by the previous line-wrap commit
• …and 280 more

• 0 containers · 5 bounded contexts · 5 dependency edges (baseline)

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

SpineEventEngine/core-jvm 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.