@spine-event-engine/server 2.0.0-snapshot.2 → 2.0.0-snapshot.20

package/dist/repository/repository.d.ts

@@ -1,7 +1,10 @@
-import { type Message } from "@bufbuild/protobuf";
+import { type Message, type MessageShape } from "@bufbuild/protobuf";
+import type { EntityQueryDescription } from "@spine-event-engine/core/codegen";
 import { type MessageSchema, StringifierRegistry } from "@spine-event-engine/core";
-import { type Command, type Event, type TenantId } from "@spine-event-engine/proto";
+import { type Command, type Event, type TenantId, type Version } from "@spine-event-engine/proto";
+import { type EntityRecord } from "@spine-event-engine/proto/generated/spine/server/entity/entity_pb.js";
 import { type StorageFactory, type StorageMode } from "@spine-event-engine/storage";
+import { SignalPublisher } from "../runtime/signal-publisher.js";
 import { type CommandRouting } from "./command-routing.js";
 import { type EventRouting } from "./event-routing.js";
 import { type StateUpdateRouting } from "./state-update-routing.js";
@@ -9,40 +12,104 @@ import type { CommandDispatcher } from "../bus/command-dispatcher.js";
 import type { EventDispatcher } from "../bus/event-dispatcher.js";
 import { Delivery } from "../delivery/delivery.js";
 import { type InboxMessage, type InboxMessageInput } from "../delivery/inbox.js";
-import { Aggregate, type Entity, ProcessManager, Projection, type EntityFamily } from "../entity/entity.js";
+import { Aggregate, type EntityOptions, ProcessManager, Projection, type EntityFamily } from "../entity/entity.js";
 import { type DescriptorFieldMetadata, type DescriptorMessageSchema, type EntityMetadata } from "../entity/entity-metadata.js";
 import { type EventHandlerFilterPlan } from "../handler/event-handler-filter.js";
 import { SignalMetadata } from "../runtime/signal-metadata.js";
-import { type CommandAssignmentHandlerMetadata, type CommandReactionHandlerMetadata, type EntityHandlersMetadata, type EventReactionHandlerMetadata, type StateSubscriptionHandlerMetadata, type RegisteredHandlerMetadata, type WhereOptions } from "../handler/handler-metadata.js";
-import { type Stand } from "../stand/stand.js";
-type RepositoryEntityInstance<Schema extends DescriptorMessageSchema = DescriptorMessageSchema> = Aggregate<unknown, Schema, unknown> | Projection<unknown, Schema, unknown> | ProcessManager<unknown, Schema, unknown>;
+import { type CommandAssignmentHandlerMetadata, type CommandReactionHandlerMetadata, type EntityHandlersMetadata, type EventReactionHandlerMetadata, type StateSubscriptionHandlerMetadata, type HandlerMetadata, type RegisteredHandlerMetadata, type WhereOptions } from "../handler/handler-metadata.js";
+import { standAccess, type Stand } from "../stand/stand.js";
 /**
- * Generated Protobuf-ES state schema carried by a repository entity constructor.
+ * Represents an Aggregate, Projection, or Process Manager with a state schema.
+ *
+ * @typeParam Schema Generated state schema of the Entity instance.
+ */
+type RepositoryEntityInstance<Schema extends DescriptorMessageSchema = DescriptorMessageSchema> = Aggregate<unknown, Schema> | Projection<unknown, Schema> | ProcessManager<unknown, Schema>;
+/**
+ * Generated state schema declared by a repository's Entity class.
+ *
+ * @typeParam EntityType Entity constructor whose state schema is selected.
+ */
+export type RepositoryStateSchema<EntityType extends RepositoryEntityType> = EntityType["prototype"] extends Aggregate<unknown, infer Schema> ? Schema : EntityType["prototype"] extends Projection<unknown, infer Schema> ? Schema : EntityType["prototype"] extends ProcessManager<unknown, infer Schema> ? Schema : never;
+/**
+ * Selects the ID type declared by a repository Entity constructor.
+ *
+ * @typeParam EntityType Entity constructor whose ID type is selected.
+ */
+export type RepositoryEntityId<EntityType extends RepositoryEntityType> = EntityType["prototype"] extends Aggregate<infer Id, DescriptorMessageSchema> ? Id : EntityType["prototype"] extends Projection<infer Id, DescriptorMessageSchema> ? Id : EntityType["prototype"] extends ProcessManager<infer Id, DescriptorMessageSchema> ? Id : never;
+/**
+ * Read operations available for one receiving repository and incoming signal tenant.
+ * The routing invocation closes this access when it finishes.
+ *
+ * @typeParam EntityType Registered application Entity class.
+ */
+export interface RepositoryReadQueries<EntityType extends RepositoryEntityType> {
+    /**
+     * Returns matching typed IDs in query order.
+     *
+     * @param query Query for this repository's state schema.
+     * @returns Every matching ID unless the query sets a limit.
+     */
+    findIds(query: EntityQueryDescription<RepositoryStateSchema<EntityType>, RepositoryEntityId<EntityType>>): Promise<readonly RepositoryEntityId<EntityType>[]>;
+    /**
+     * Returns independent complete generated state messages.
+     *
+     * @param query Query for this repository's state schema.
+     * @returns Detached states in query order.
+     */
+    findStates(query: EntityQueryDescription<RepositoryStateSchema<EntityType>, RepositoryEntityId<EntityType>>): Promise<readonly MessageShape<RepositoryStateSchema<EntityType>>[]>;
+    /**
+     * Restores application Entity instances with stored versions and lifecycle flags.
+     *
+     * @param query Query for this repository's state schema.
+     * @returns Registered application instances in query order.
+     */
+    find(query: EntityQueryDescription<RepositoryStateSchema<EntityType>, RepositoryEntityId<EntityType>>): Promise<readonly InstanceType<EntityType>[]>;
+}
+/**
+ * Describes handler metadata compatible with an Entity constructor.
+ *
+ * @typeParam EntityType Entity constructor represented by the handlers.
  */
-export type RepositoryStateSchema<EntityType extends RepositoryEntityType> = EntityType["prototype"] extends Aggregate<infer Id, infer Schema, infer Version> ? [Id, Version] extends [unknown, unknown] ? Schema : never : EntityType["prototype"] extends Projection<infer Id, infer Schema, infer Version> ? [Id, Version] extends [unknown, unknown] ? Schema : never : EntityType["prototype"] extends ProcessManager<infer Id, infer Schema, infer Version> ? [Id, Version] extends [unknown, unknown] ? Schema : never : never;
-type RepositoryEntityId<EntityType extends RepositoryEntityType> = EntityType["prototype"] extends Aggregate<infer Id, DescriptorMessageSchema, unknown> ? Id : EntityType["prototype"] extends Projection<infer Id, DescriptorMessageSchema, unknown> ? Id : EntityType["prototype"] extends ProcessManager<infer Id, DescriptorMessageSchema, unknown> ? Id : never;
 type RepositoryHandlers<EntityType extends RepositoryEntityType> = EntityType["prototype"] extends infer Instance extends object ? EntityHandlersMetadata<Instance, RepositoryStateSchema<EntityType>> : never;
-type RepositoryHandlersOptionFor<EntityType extends RepositoryEntityType> = EntityType["prototype"] extends Aggregate<unknown, DescriptorMessageSchema, infer Version> ? [Version] extends [bigint] ? RepositoryHandlers<EntityType> | readonly RepositoryHandlers<EntityType>[] : never : EntityType["prototype"] extends Projection<unknown, DescriptorMessageSchema, infer Version> ? [Version] extends [number] ? RepositoryHandlers<EntityType> | readonly RepositoryHandlers<EntityType>[] : never : EntityType["prototype"] extends ProcessManager<unknown, DescriptorMessageSchema, infer Version> ? [Version] extends [number] ? RepositoryHandlers<EntityType> | readonly RepositoryHandlers<EntityType>[] : never : never;
-type StateRoutingOption<EntityType extends RepositoryEntityType> = EntityType["prototype"] extends Projection<unknown, DescriptorMessageSchema, unknown> ? StateUpdateRouting<RepositoryEntityId<EntityType>> : never;
+/**
+ * Accepts one or several handler metadata blocks for an Entity constructor.
+ *
+ * @typeParam EntityType Entity constructor represented by the handlers.
+ */
+type RepositoryHandlersOptionFor<EntityType extends RepositoryEntityType> = RepositoryHandlers<EntityType> | readonly RepositoryHandlers<EntityType>[];
+/**
+ * Allows state-update routing only for Projection constructors.
+ *
+ * @typeParam EntityType Entity constructor being configured.
+ */
+type StateRoutingOption<EntityType extends RepositoryEntityType> = EntityType["prototype"] extends Projection<unknown, DescriptorMessageSchema> ? StateUpdateRouting<RepositoryEntityId<EntityType>, NoInfer<EntityType>> | StateUpdateRouting<RepositoryEntityId<EntityType>> : never;
+/**
+ * Detects a TypeScript union while preserving the complete input type.
+ *
+ * @typeParam Type Candidate type to test.
+ * @typeParam Union Original unsplit candidate type.
+ */
 type IsUnion<Type, Union = Type> = Type extends unknown ? [Union] extends [Type] ? false : true : false;
 /**
- * Single concrete entity constructor accepted by repository identity metadata.
+ * Checks whether a repository binds one concrete Entity class and state schema.
  *
  * Concrete aggregate, projection, and process-manager classes satisfy this type naturally. Broad
  * constructor aliases, constructor unions, broad state schemas, and state-schema unions are
- * rejected so repository identities cannot erase which state schema the entity owns.
+ * rejected so a repository cannot lose its Entity class's state schema.
+ *
+ * @typeParam EntityType Candidate concrete Entity constructor.
  */
 export type ConcreteRepositoryEntityType<EntityType extends RepositoryEntityType> = IsUnion<EntityType> extends true ? never : RepositoryEntityType extends EntityType ? never : [ConstructorParameters<EntityType>] extends [never[]] ? never : IsUnion<RepositoryStateSchema<EntityType>> extends true ? never : DescriptorMessageSchema extends RepositoryStateSchema<EntityType> ? never : unknown;
 /**
- * Describes an entity constructor accepted by repository identity metadata.
+ * Describes an Aggregate, Projection, or Process Manager class accepted by a repository.
  *
- * @typeParam Instance - The aggregate, projection, or process-manager instance type.
+ * @typeParam Instance The aggregate, projection, or process-manager instance type.
  * @param args The constructor arguments accepted by the entity class.
  * @returns An entity instance.
  */
-export type RepositoryEntityType<Instance extends RepositoryEntityInstance = RepositoryEntityInstance> = (abstract new (...args: never[]) => Instance) & typeof Entity<any, DescriptorMessageSchema, any> & {
+export type RepositoryEntityType<Instance extends RepositoryEntityInstance = RepositoryEntityInstance> = (abstract new (...args: never[]) => Instance) & {
     /**
-     * Prototype inspected for built-in entity family marker inheritance.
+     * Prototype used to identify the Entity family and state schema.
      */
     readonly prototype: Instance;
     /**
@@ -51,40 +118,46 @@ export type RepositoryEntityType<Instance extends RepositoryEntityInstance = Rep
     readonly name: string;
 };
 /**
- * Options for constructing repository identity and context-owned registration.
+ * Entity class, state schema, and routing options for a repository.
  *
- * @typeParam EntityType - A single concrete aggregate, projection, or process-manager constructor.
+ * @typeParam EntityType A single concrete aggregate, projection, or process-manager constructor.
  * The constructor's prototype must carry one concrete generated state schema; broad constructor,
  * constructor-union, broad-schema, and schema-union bindings are rejected at compile time.
  */
-export interface RepositoryOptions<EntityType extends RepositoryEntityType & ConcreteRepositoryEntityType<EntityType>> {
+interface RepositoryOptionsBase<EntityType extends RepositoryEntityType & ConcreteRepositoryEntityType<EntityType>> {
     /**
-     * Entity constructor owned by this repository identity.
+     * Entity class constructed by this repository.
      */
     readonly entityType: EntityType;
     /**
-     * Generated Protobuf-ES schema for the entity state owned by this repository identity.
+     * Generated schema for this repository's Entity state.
      */
     readonly schema: RepositoryStateSchema<EntityType>;
     /**
-     * Explicit handler metadata used to register repository command and event routing.
+     * Constructs each new or restored Entity with application dependencies.
      *
-     * Aggregate repositories with handlers can be executed by built bounded contexts and therefore
-     * must use `bigint` version metadata, matching the persisted aggregate history version type.
-     * Projection repositories with handlers can be executed by built bounded contexts and therefore
-     * must use `number` version metadata, matching the protobuf event version carried into Stand.
-     * Process-manager repositories with handlers also execute through Stand-backed state and must
-     * use `number` version metadata, matching the Stand version shape used by the local runtime.
+     * The callback receives the framework's ID, schema, state, Version, and lifecycle options.
+     * It must synchronously return a fresh instance of `entityType` that passes those options to
+     * the Entity base constructor. Shared services should be created before context startup and
+     * closed by the application after context shutdown.
+     *
+     * @param options Framework identity, state, Version, and lifecycle values.
+     * @returns A synchronous instance of the registered Entity class.
+     */
+    readonly onCreate?: (options: EntityOptions<RepositoryEntityId<EntityType>, RepositoryStateSchema<EntityType>>) => InstanceType<EntityType>;
+    /**
+     * Explicit handler metadata used to register repository command and event routing.
+     * The metadata must describe this repository's Entity constructor and state schema.
      */
     readonly handlers?: RepositoryHandlersOptionFor<EntityType>;
     /**
      * Mutable Command route declarations snapshotted when this repository is constructed.
      */
-    readonly commandRouting?: CommandRouting<RepositoryEntityId<EntityType>>;
+    readonly commandRouting?: CommandRouting<RepositoryEntityId<EntityType>, NoInfer<EntityType>> | CommandRouting<RepositoryEntityId<EntityType>>;
     /**
      * Mutable Event route declarations snapshotted when this repository is constructed.
      */
-    readonly eventRouting?: EventRouting<RepositoryEntityId<EntityType>>;
+    readonly eventRouting?: EventRouting<RepositoryEntityId<EntityType>, NoInfer<EntityType>> | EventRouting<RepositoryEntityId<EntityType>>;
     /**
      * Mutable state-update declarations allowed only for Projections.
      */
@@ -120,32 +193,63 @@ export interface RepositoryOptions<EntityType extends RepositoryEntityType & Con
         readonly depth?: number;
     };
 }
+/**
+ * Requires a creation callback when the Entity constructor needs application arguments.
+ *
+ * @typeParam EntityType Concrete Entity constructor configured by this repository.
+ */
+type RepositoryCreationOption<EntityType extends RepositoryEntityType> = [EntityType] extends [
+    new (options: EntityOptions<RepositoryEntityId<EntityType>, RepositoryStateSchema<EntityType>>) => InstanceType<EntityType>
+] ? {
+    readonly onCreate?: OnCreate<EntityType>;
+} : {
+    readonly onCreate: OnCreate<EntityType>;
+};
+/**
+ * Constructs the registered Entity from framework-supplied options.
+ *
+ * @typeParam EntityType Concrete Entity constructor configured by the repository.
+ * @param options Framework identity, state, Version, and lifecycle values.
+ * @returns One new Entity instance.
+ */
+type OnCreate<EntityType extends RepositoryEntityType> = (options: EntityOptions<RepositoryEntityId<EntityType>, RepositoryStateSchema<EntityType>>) => InstanceType<EntityType>;
+/**
+ * Configures repository identity, routing, and optional Entity constructor injection.
+ *
+ * `onCreate` is required when `EntityType` needs constructor arguments beyond framework
+ * `EntityOptions`. The callback runs for new and restored instances before handlers; it receives
+ * the authoritative options and must return a synchronous instance of the registered class.
+ * Framework history, queries, transactions, and persistence remain configured separately.
+ *
+ * @typeParam EntityType A single concrete Entity constructor and state schema.
+ */
+export type RepositoryOptions<EntityType extends RepositoryEntityType & ConcreteRepositoryEntityType<EntityType>> = RepositoryOptionsBase<EntityType> & RepositoryCreationOption<EntityType>;
 /**
  * Immutable copy-safe repository identity snapshot.
  *
- * @typeParam EntityType - The concrete entity constructor owned by the repository. The snapshot's
+ * @typeParam EntityType The concrete entity constructor represented by the repository. The snapshot's
  * state schema and metadata are derived from this constructor so callers cannot spell an impossible
  * entity/schema snapshot pair.
  */
 export interface RepositoryIdentitySnapshot<EntityType extends RepositoryEntityType = RepositoryEntityType> {
     /**
-     * Entity constructor owned by the repository.
+     * Entity class registered with the repository.
      */
     readonly entityType: EntityType;
     /**
-     * Entity family inferred from the constructor's built-in family marker base class.
+     * Aggregate, Projection, or Process Manager family of the Entity class.
      */
     readonly entityFamily: EntityFamily;
     /**
-     * Generated Protobuf-ES schema for the owned entity state.
+     * Generated schema for the Entity state.
      */
     readonly stateSchema: RepositoryStateSchema<EntityType>;
     /**
-     * Descriptor-derived metadata for the owned entity state.
+     * Descriptor metadata for the Entity state.
      */
     readonly metadata: EntityMetadata<RepositoryStateSchema<EntityType>>;
     /**
-     * Fully qualified Protobuf type name of the owned entity state.
+     * Fully qualified Protobuf name of the Entity state type.
      */
     readonly stateFullTypeName: RepositoryStateSchema<EntityType>["typeName"];
     /**
@@ -158,23 +262,23 @@ export interface RepositoryIdentitySnapshot<EntityType extends RepositoryEntityT
  */
 export interface RepositoryView {
     /**
-     * Entity constructor owned by the repository.
+     * Entity class registered with the repository.
      */
     readonly entityType: RepositoryEntityType;
     /**
-     * Entity family inferred from the constructor's built-in family marker base class.
+     * Aggregate, Projection, or Process Manager family of the Entity class.
      */
     readonly entityFamily: EntityFamily;
     /**
-     * Generated Protobuf-ES schema for the owned entity state.
+     * Generated schema for the Entity state.
      */
     readonly stateSchema: DescriptorMessageSchema;
     /**
-     * Descriptor-derived metadata for the owned entity state.
+     * Descriptor metadata for the Entity state.
      */
     readonly metadata: EntityMetadata;
     /**
-     * Fully qualified Protobuf type name of the owned entity state.
+     * Fully qualified Protobuf name of the Entity state type.
      */
     readonly stateFullTypeName: string;
     /**
@@ -191,7 +295,7 @@ export interface RepositoryView {
  */
 export type RepositoryIdentityErrorCode = "ENTITY_SCHEMA_KIND_MISMATCH" | "UNSUPPORTED_ENTITY_TYPE";
 /**
- * Describes an error raised when repository identity metadata cannot be constructed.
+ * Error raised when an Entity class and state schema cannot form a repository.
  */
 export declare class RepositoryIdentityError extends Error {
     /**
@@ -207,30 +311,17 @@ export declare class RepositoryIdentityError extends Error {
     constructor(code: RepositoryIdentityErrorCode, message: string);
 }
 /**
- * Repository identity and context-owned storage registration over one entity constructor and state schema.
+ * Configures storage and handlers for one Entity class.
  *
- * The class records the ownership facts bounded-context registration needs for
- * duplicate and conflict checks. Context assembly uses this metadata to attach
- * a repository to one built context and open state record storage. With
- * authentic explicit aggregate handler metadata, the built context can also
- * execute aggregate commands through repository-owned assignees and live
- * direct transactional handlers, persist the latest aggregate state plus a diagnostic event journal,
- * and hand already-stored events to the event bus. Aggregate and process-manager command
- * execution require `command.id` before routing or mutation so produced events
- * can carry a contract-valid command origin. With authentic projection
- * subscriber metadata, built contexts can also execute projection subscribers
- * and write changed projection state through the context-owned `Stand`. With
- * authentic process-manager metadata, built contexts can execute command
- * assignees, event reactors, and event-commanding handlers, storing changed
- * process-manager state through tenant-scoped Stand records with numeric
- * versions. The `events` option declares generated event schemas emitted by
- * aggregate and process-manager producer handlers. The repository surface still
- * does not expose direct entity lookup/storage APIs, inbox/delivery management,
- * caches, lifecycle monitors, or transport startup.
+ * Construction selects the Entity class, state schema, routing, and optional
+ * creation callback. A Bounded Context builder registers the repository. During
+ * context assembly, it opens record storage and installs handlers and Inbox
+ * targets. Aggregate handlers store state and a diagnostic event journal;
+ * Projection and Process Manager handlers store state in Stand. The `events`
+ * option lists generated event schemas that handlers may emit.
  *
- * @typeParam EntityType - A single concrete aggregate, projection, or process-manager constructor
- * with one concrete generated state schema. Broad constructor, constructor-union, broad-schema, and
- * schema-union bindings intentionally fail the public type constraint.
+ * @typeParam EntityType One concrete Aggregate, Projection, or Process Manager
+ * class with one generated state schema.
  */
 export declare class Repository<EntityType extends RepositoryEntityType & ConcreteRepositoryEntityType<EntityType>> implements RepositoryView {
     #private;
@@ -241,9 +332,9 @@ export declare class Repository<EntityType extends RepositoryEntityType & Concre
      */
     constructor(options: RepositoryOptions<EntityType>);
     /**
-     * Returns the entity constructor owned by this repository identity.
+     * Returns the Entity class registered with this repository.
      *
-     * @returns The owned entity constructor.
+     * @returns The registered Entity class.
      */
     get entityType(): EntityType;
     /**
@@ -255,7 +346,7 @@ export declare class Repository<EntityType extends RepositoryEntityType & Concre
     /**
      * Returns the generated schema for this repository's entity state.
      *
-     * @returns The owned state schema.
+     * @returns The Entity state schema.
      */
     get stateSchema(): RepositoryStateSchema<EntityType>;
     /**
@@ -268,13 +359,13 @@ export declare class Repository<EntityType extends RepositoryEntityType & Concre
      */
     setStateHistoryEnabled(enabled: boolean): void;
     /**
-     * Returns descriptor-derived metadata for the owned entity state.
+     * Returns descriptor metadata for this repository's Entity state.
      *
-     * @returns A metadata view for the owned state.
+     * @returns Descriptor metadata for the Entity state.
      */
     get metadata(): EntityMetadata<RepositoryStateSchema<EntityType>>;
     /**
-     * Returns the fully qualified Protobuf name of the owned entity state.
+     * Returns the fully qualified Protobuf name of the Entity state.
      *
      * @returns The state message type name.
      */
@@ -297,7 +388,7 @@ export declare class Repository<EntityType extends RepositoryEntityType & Concre
      * @param command The command envelope to route.
      * @returns The calculated command route.
      */
-    routeCommand(command: Command): RepositoryCommandRoute<RepositoryEntityId<EntityType>>;
+    routeCommand(command: Command): Promise<RepositoryCommandRoute<RepositoryEntityId<EntityType>>>;
     /**
      * Routes an Event without invoking a handler.
      *
@@ -310,7 +401,7 @@ export declare class Repository<EntityType extends RepositoryEntityType & Concre
      * @param event The event envelope to route.
      * @returns The calculated event route.
      */
-    routeEvent(event: Event): RepositoryEventRoute<RepositoryEntityId<EntityType>>;
+    routeEvent(event: Event): Promise<RepositoryEventRoute<RepositoryEntityId<EntityType>>>;
 }
 /**
  * Route-only invocation marker returned by direct repository routing APIs.
@@ -321,6 +412,8 @@ export declare class Repository<EntityType extends RepositoryEntityType & Concre
 export type RepositoryRouteInvocation = "deferred";
 /**
  * Command route calculated by a repository.
+ *
+ * @typeParam Id Target Entity identifier type.
  */
 export interface RepositoryCommandRoute<Id = unknown> {
     /**
@@ -338,6 +431,8 @@ export interface RepositoryCommandRoute<Id = unknown> {
 }
 /**
  * Event route calculated by a repository.
+ *
+ * @typeParam Id Target Entity identifier type.
  */
 export interface RepositoryEventRoute<Id = unknown> {
     /**
@@ -356,6 +451,7 @@ export interface RepositoryEventRoute<Id = unknown> {
 /**
  * Route calculated for one unpacked Entity state update.
  *
+ * @typeParam Id Target Projection identifier type.
  * @internal Framework delivery metadata.
  */
 interface RepositoryStateUpdateRoute<Id = unknown> extends RepositoryEventRoute<Id> {
@@ -400,13 +496,13 @@ export interface EntityInboxTarget {
     replay(message: EntityInboxMessage, deliveryTenantId?: TenantId): EntityInboxReplay;
 }
 /**
- * Defines context-owned Entity Inbox handoff operations.
+ * Operations the Bounded Context uses to deliver Entity Inbox messages.
  *
  * @internal
  */
 export interface EntityInbox {
     /**
-     * Returns the context-owned target-to-shard strategy.
+     * Returns the strategy that maps Entity Inbox targets to shards.
      *
      * @returns The immutable delivery strategy.
      */
@@ -470,7 +566,7 @@ export interface ProjectionInboxTarget {
     replay(message: ProjectionInboxMessage, deliveryTenantId?: TenantId): Promise<void>;
 }
 /**
- * Defines context-owned projection subscriber inbox handoff operations.
+ * Operations the Bounded Context uses to deliver Projection Inbox messages.
  *
  * @internal
  */
@@ -555,7 +651,7 @@ export interface RepositoryAccess {
      * @param event The Entity state-change System event.
      * @returns The calculated route, or `undefined` for an unrelated state.
      */
-    routeStateUpdate(repository: RepositoryView, event: Event): RepositoryStateUpdateRoute | undefined;
+    routeStateUpdate(repository: RepositoryView, event: Event): Promise<RepositoryStateUpdateRoute | undefined>;
     /**
      * Returns the Entity Inbox target configured for a repository.
      *
@@ -606,39 +702,173 @@ interface RepositoryRuntime {
     readonly signalMetadata: SignalMetadata;
     readonly entityInbox: EntityInbox;
     readonly projectionInbox: ProjectionInbox;
-    readonly dispatchStored: (event: Event) => Promise<void>;
-    readonly dispatchStoredFollowUp: (event: Event) => Promise<void>;
-    readonly postEventFollowUp: (event: Event) => Promise<void>;
+    readonly publisher: SignalPublisher;
     readonly registerEventSchema: (schema: MessageSchema) => void;
-    readonly postSystemFollowUp: (event: Event) => Promise<void>;
     readonly registerSystemEventSchema: (schema: MessageSchema) => void;
-    readonly onPostCommand: (command: Command) => Promise<void>;
-    readonly recordDispatchFailure: (event: Event, error: unknown) => void;
 }
 type RepositoryHandlersOption = EntityHandlersMetadata | readonly EntityHandlersMetadata[] | undefined;
 type RepositoryStateSubscribers = readonly RegisteredHandlerMetadata<StateSubscriptionHandlerMetadata>[];
+/**
+ * Binds repository queries to a single routing invocation's tenant and lifetime.
+ * Routing integration closes the returned access after its callback settles.
+ *
+ * @internal
+ */
+export declare const repositoryReadAccess: Readonly<{
+    /**
+     * Binds one repository and incoming signal tenant to a read-only scope.
+     *
+     * @typeParam EntityType Registered application Entity class.
+     * @param repository Receiving repository with an active runtime.
+     * @param tenantId Signal tenant for a multitenant context.
+     * @returns Read methods and the invocation close operation.
+     */
+    bind<EntityType extends RepositoryEntityType>(repository: RepositoryView & {
+        readonly entityType: EntityType;
+    }, tenantId?: TenantId): RepositoryReadQueries<EntityType> & {
+        close(): void;
+    };
+}>;
+/**
+ * Internal repository stand operations.
+ * @internal
+ */
+export declare const RepositoryStand: {
+    /**
+     * Returns the validated Stand snapshot with the authoritative routed ID.
+     *
+     * @param repository Supplies the state schema and validated ID descriptor.
+     * @param deferred Contains the prepared Stand record.
+     * @param entityId Authoritative routed Entity identifier.
+     * @returns An isolated prepared record with the authoritative packed ID.
+     */
+    preparedRecord(repository: RepositoryView, deferred: Awaited<ReturnType<typeof standAccess.deferUpdate>>, entityId: unknown): EntityRecord;
+    /**
+     * Builds tenant, Version, and lifecycle options for a Stand update.
+     *
+     * @param tenantId Tenant receiving the update, when present.
+     * @param version Committed Spine Version, when present.
+     * @param lifecycle Accepted archived and deleted flags.
+     * @returns Frozen Stand update options.
+     */
+    standUpdateOptions(tenantId: TenantId | undefined, version: Version | undefined, lifecycle: {
+        readonly archived: boolean;
+        readonly deleted: boolean;
+    }): {
+        readonly tenantId?: TenantId;
+        readonly version?: Version;
+        readonly lifecycle: {
+            readonly archived: boolean;
+            readonly deleted: boolean;
+        };
+    };
+};
 /**
  * Internal repository handlers operations.
  */
 declare const RepositoryHandlers: {
+    /**
+     * Rejects outputs not declared by the invoked handler, even if a sibling declares them.
+     *
+     * @param handler Invoked handler declaration.
+     * @param signals Returned domain messages to validate.
+     */
+    requireDeclaredOutputs(handler: HandlerMetadata, signals: readonly unknown[]): void;
+    /**
+     * Normalizes one or many handler metadata blocks to a frozen list.
+     *
+     * @param handlersOption Configured handler metadata.
+     * @returns Frozen handler metadata list.
+     */
     normalizeHandlers(handlersOption: RepositoryHandlersOption): readonly EntityHandlersMetadata[];
+    /**
+     * Groups Event-to-Command reactions by source Event type.
+     *
+     * @param handlers Entity handler metadata blocks.
+     * @returns Reactions indexed by Event type name.
+     */
     createCommandReactionMap(handlers: readonly EntityHandlersMetadata[]): ReadonlyMap<string, readonly RegisteredHandlerMetadata<CommandReactionHandlerMetadata>[]>;
+    /**
+     * Builds Event field filters for handlers grouped by Event type.
+     *
+     * @typeParam Value Handler registration carrying schema and filter metadata.
+     * @param byEvent Handler registrations indexed by Event type.
+     * @param stringifiers Field conversion registry for message-valued filters.
+     * @returns Compiled filter plans by Event type.
+     */
     createEventFilterPlans<Value extends {
         readonly handler: {
             readonly schema: DescriptorMessageSchema;
             readonly where?: WhereOptions;
         };
     }>(byEvent: ReadonlyMap<string, readonly Value[]>, stringifiers: StringifierRegistry): ReadonlyMap<string, EventHandlerFilterPlan<Value>>;
+    /**
+     * Finds handlers for domestic or external Event origin.
+     *
+     * @typeParam Value Handler registration with origin metadata.
+     * @param values Candidate handler registrations.
+     * @param external Whether the source Event is external.
+     * @returns Frozen matching registration list.
+     */
     forOrigin<Value extends {
         readonly handler: {
             readonly origin: "domestic" | "external";
         };
     }>(values: readonly Value[], external: boolean): readonly Value[];
+    /**
+     * Maps readiness-selected handlers by registered message type.
+     *
+     * @typeParam Value Handler registration returned by readiness lookup.
+     * @param schemas Registered message schemas.
+     * @param find Selects handlers for one type name.
+     * @returns Handler lists indexed by message type name.
+     */
     readinessMap<Value>(schemas: readonly MessageSchema[], find: (typeName: string) => readonly Value[]): ReadonlyMap<string, readonly Value[]>;
-    handlerEmittedSchemas(handler: CommandAssignmentHandlerMetadata | CommandReactionHandlerMetadata | EventReactionHandlerMetadata): readonly DescriptorMessageSchema[];
+    /**
+     * Reads the declared output schemas for one handler.
+     *
+     * @param handler Command or Event handler declaration.
+     * @returns Generated schemas the handler may emit.
+     */
+    handlerEmittedSchemas(handler: CommandAssignmentHandlerMetadata | import("../handler/handler-metadata.js").CommandSubstitutionHandlerMetadata | CommandReactionHandlerMetadata | EventReactionHandlerMetadata): readonly DescriptorMessageSchema[];
+    /**
+     * Reads the declared rejection schemas for a Command handler.
+     *
+     * @param handler Assignment or substitution declaration.
+     * @returns Generated rejection schemas the handler may throw.
+     */
+    handlerThrownSchemas(handler: CommandAssignmentHandlerMetadata | import("../handler/handler-metadata.js").CommandSubstitutionHandlerMetadata): readonly DescriptorMessageSchema[];
+    /**
+     * Checks whether handler metadata was supplied as a list.
+     *
+     * @param value Configured handler metadata.
+     * @returns Whether it is a handler list.
+     */
     isHandlersArray(value: RepositoryHandlersOption): value is readonly EntityHandlersMetadata[];
+    /**
+     * Validates handler metadata against the Entity constructor and family.
+     *
+     * @param entityType Repository Entity constructor.
+     * @param metadata Descriptor-derived state metadata.
+     * @param handlers Handler metadata blocks to validate.
+     */
     validateHandlers(entityType: RepositoryEntityType, metadata: EntityMetadata, handlers: readonly EntityHandlersMetadata[]): void;
+    /**
+     * Returns unique generated schemas by type URL.
+     *
+     * @param schemas Candidate message schemas.
+     * @returns Frozen list retaining the last schema for each type URL.
+     */
     uniqueSchemas(schemas: readonly MessageSchema[]): readonly MessageSchema[];
+    /**
+     * Adds a value to a map entry, creating its list when absent.
+     *
+     * @typeParam Key Map key type.
+     * @typeParam Value Map value type.
+     * @param map Mutable map of value lists.
+     * @param key Entry key to update.
+     * @param value Value to append.
+     */
     pushMapValue<Key, Value>(map: Map<Key, Value[]>, key: Key, value: Value): void;
 };
 /**
@@ -648,14 +878,14 @@ declare const repositoryHistory: {
     /**
      * Creates a cache that extends a repository history only when a caller requests more entries.
      *
-     * @typeParam Entry - The history entry type.
+     * @typeParam Entry The history entry type.
      * @param load Loads entries before an optional continuation version.
      * @param versionOf Reads the optional version carried by an entry.
-     * @param options Selects contiguous-version and complete-group behavior.
+     * @param options Selects strictly descending-version and complete-group behavior.
      * @returns A cache with read and clear operations.
      */
     createCache<Entry>(load: (depth: number, startingFromVersion?: bigint) => Promise<readonly Entry[]>, versionOf: (entry: Entry) => bigint | undefined, options?: {
-        readonly requireContiguousVersions?: boolean;
+        readonly requireDescendingVersions?: boolean;
         readonly cacheCompleteVersionGroups?: boolean;
     }): {
         readonly read: (depth: number) => Promise<readonly Entry[]>;