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

package/dist/repository/repository.d.ts

@@ -0,0 +1,670 @@
+import { type Message } from "@bufbuild/protobuf";
+import { type MessageSchema, StringifierRegistry } from "@spine-event-engine/core";
+import { type Command, type Event, type TenantId } from "@spine-event-engine/proto";
+import { type StorageFactory, type StorageMode } from "@spine-event-engine/storage";
+import { type CommandRouting } from "./command-routing.js";
+import { type EventRouting } from "./event-routing.js";
+import { type StateUpdateRouting } from "./state-update-routing.js";
+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 { 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>;
+/**
+ * Generated Protobuf-ES state schema carried by a repository entity constructor.
+ */
+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;
+type IsUnion<Type, Union = Type> = Type extends unknown ? [Union] extends [Type] ? false : true : false;
+/**
+ * Single concrete entity constructor accepted by repository identity metadata.
+ *
+ * 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.
+ */
+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.
+ *
+ * @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> & {
+    /**
+     * Prototype inspected for built-in entity family marker inheritance.
+     */
+    readonly prototype: Instance;
+    /**
+     * Constructor name used in structured diagnostics.
+     */
+    readonly name: string;
+};
+/**
+ * Options for constructing repository identity and context-owned registration.
+ *
+ * @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>> {
+    /**
+     * Entity constructor owned by this repository identity.
+     */
+    readonly entityType: EntityType;
+    /**
+     * Generated Protobuf-ES schema for the entity state owned by this repository identity.
+     */
+    readonly schema: RepositoryStateSchema<EntityType>;
+    /**
+     * Explicit handler metadata used to register repository command and event routing.
+     *
+     * 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.
+     */
+    readonly handlers?: RepositoryHandlersOptionFor<EntityType>;
+    /**
+     * Mutable Command route declarations snapshotted when this repository is constructed.
+     */
+    readonly commandRouting?: CommandRouting<RepositoryEntityId<EntityType>>;
+    /**
+     * Mutable Event route declarations snapshotted when this repository is constructed.
+     */
+    readonly eventRouting?: EventRouting<RepositoryEntityId<EntityType>>;
+    /**
+     * Mutable state-update declarations allowed only for Projections.
+     */
+    readonly stateUpdateRouting?: StateRoutingOption<EntityType>;
+    /**
+     * Reversible field mappings used by generated Event handler filters.
+     *
+     * Pass the same source registry configured for storage/query mappings when
+     * message-valued fields use application-defined string representations. The
+     * repository snapshots the registry during construction.
+     */
+    readonly stringifierRegistry?: StringifierRegistry;
+    /**
+     * Generated event schemas that aggregate or process-manager handlers may emit.
+     */
+    readonly events?: readonly MessageSchema[];
+    /**
+     * Retain a state-history row after each successful logical store. Defaults to false.
+     */
+    readonly stateHistory?: boolean;
+    /**
+     * Retain process-manager diagnostic events. Defaults to false; aggregate events are retained.
+     */
+    readonly processManagerEventHistory?: boolean;
+    /**
+     * Enables a bounded best-effort, in-process duplicate-dispatch guard.
+     *
+     * The guard is disabled by default and uses depth 100 when enabled without
+     * an explicit depth. Projection repositories cannot enable it. Process
+     * Manager repositories must also enable `processManagerEventHistory`.
+     */
+    readonly doubleDispatchGuard?: boolean | {
+        readonly depth?: number;
+    };
+}
+/**
+ * Immutable copy-safe repository identity snapshot.
+ *
+ * @typeParam EntityType - The concrete entity constructor owned 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.
+     */
+    readonly entityType: EntityType;
+    /**
+     * Entity family inferred from the constructor's built-in family marker base class.
+     */
+    readonly entityFamily: EntityFamily;
+    /**
+     * Generated Protobuf-ES schema for the owned entity state.
+     */
+    readonly stateSchema: RepositoryStateSchema<EntityType>;
+    /**
+     * Descriptor-derived metadata for the owned entity state.
+     */
+    readonly metadata: EntityMetadata<RepositoryStateSchema<EntityType>>;
+    /**
+     * Fully qualified Protobuf type name of the owned entity state.
+     */
+    readonly stateFullTypeName: RepositoryStateSchema<EntityType>["typeName"];
+    /**
+     * Canonical entity ID field copied from descriptor-derived metadata.
+     */
+    readonly idField: DescriptorFieldMetadata;
+}
+/**
+ * Public read view of a repository registered with a bounded context.
+ */
+export interface RepositoryView {
+    /**
+     * Entity constructor owned by the repository.
+     */
+    readonly entityType: RepositoryEntityType;
+    /**
+     * Entity family inferred from the constructor's built-in family marker base class.
+     */
+    readonly entityFamily: EntityFamily;
+    /**
+     * Generated Protobuf-ES schema for the owned entity state.
+     */
+    readonly stateSchema: DescriptorMessageSchema;
+    /**
+     * Descriptor-derived metadata for the owned entity state.
+     */
+    readonly metadata: EntityMetadata;
+    /**
+     * Fully qualified Protobuf type name of the owned entity state.
+     */
+    readonly stateFullTypeName: string;
+    /**
+     * Canonical entity ID field copied from descriptor-derived metadata.
+     */
+    readonly idField: DescriptorFieldMetadata;
+    /**
+     * Copy-safe immutable identity snapshot for duplicate/conflict checks.
+     */
+    readonly snapshot: RepositoryIdentitySnapshot;
+}
+/**
+ * Machine-readable codes for repository identity failures.
+ */
+export type RepositoryIdentityErrorCode = "ENTITY_SCHEMA_KIND_MISMATCH" | "UNSUPPORTED_ENTITY_TYPE";
+/**
+ * Describes an error raised when repository identity metadata cannot be constructed.
+ */
+export declare class RepositoryIdentityError extends Error {
+    /**
+     * Stable code for callers/tests that need structured failure handling.
+     */
+    readonly code: RepositoryIdentityErrorCode;
+    /**
+     * Creates a repository identity error.
+     *
+     * @param code The stable reason for the failed identity.
+     * @param message The diagnostic message.
+     */
+    constructor(code: RepositoryIdentityErrorCode, message: string);
+}
+/**
+ * Repository identity and context-owned storage registration over one entity constructor and state schema.
+ *
+ * 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.
+ *
+ * @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.
+ */
+export declare class Repository<EntityType extends RepositoryEntityType & ConcreteRepositoryEntityType<EntityType>> implements RepositoryView {
+    #private;
+    /**
+     * Creates repository identity for one entity family and state schema pair.
+     *
+     * @param options The entity constructor, state schema, and optional routing configuration.
+     */
+    constructor(options: RepositoryOptions<EntityType>);
+    /**
+     * Returns the entity constructor owned by this repository identity.
+     *
+     * @returns The owned entity constructor.
+     */
+    get entityType(): EntityType;
+    /**
+     * Returns the entity family inferred from its constructor.
+     *
+     * @returns The aggregate, projection, or process-manager family.
+     */
+    get entityFamily(): EntityFamily;
+    /**
+     * Returns the generated schema for this repository's entity state.
+     *
+     * @returns The owned state schema.
+     */
+    get stateSchema(): RepositoryStateSchema<EntityType>;
+    /**
+     * Sets whether future state-history rows are appended for this repository.
+     *
+     * This JVM-parity switch is for controlled administration/testing, not
+     * routine request-time behavior. It never deletes or reconstructs history.
+     *
+     * @param enabled Whether later successful stores append state-history rows.
+     */
+    setStateHistoryEnabled(enabled: boolean): void;
+    /**
+     * Returns descriptor-derived metadata for the owned entity state.
+     *
+     * @returns A metadata view for the owned state.
+     */
+    get metadata(): EntityMetadata<RepositoryStateSchema<EntityType>>;
+    /**
+     * Returns the fully qualified Protobuf name of the owned entity state.
+     *
+     * @returns The state message type name.
+     */
+    get stateFullTypeName(): RepositoryStateSchema<EntityType>["typeName"];
+    /**
+     * Returns a copy of the canonical entity ID field metadata.
+     *
+     * @returns The descriptor field used as the entity ID.
+     */
+    get idField(): DescriptorFieldMetadata;
+    /**
+     * Returns a copy-safe identity snapshot for builder duplicate and conflict checks.
+     *
+     * @returns An immutable snapshot of the repository identity.
+     */
+    get snapshot(): RepositoryIdentitySnapshot<EntityType>;
+    /**
+     * Routes a command to one entity ID without invoking a handler.
+     *
+     * @param command The command envelope to route.
+     * @returns The calculated command route.
+     */
+    routeCommand(command: Command): RepositoryCommandRoute<RepositoryEntityId<EntityType>>;
+    /**
+     * Routes an Event without invoking a handler.
+     *
+     * The default route uses a readable producer whose typed ID is compatible
+     * with the Entity ID. A valid producer of another type falls back to the
+     * Event's declaration-first field. A producer that claims the compatible type
+     * but cannot be decoded is rejected. Custom routes may select zero, one, or
+     * many targets.
+     *
+     * @param event The event envelope to route.
+     * @returns The calculated event route.
+     */
+    routeEvent(event: Event): RepositoryEventRoute<RepositoryEntityId<EntityType>>;
+}
+/**
+ * Route-only invocation marker returned by direct repository routing APIs.
+ *
+ * Built bounded contexts may execute aggregate command assignees and event reactions through their
+ * command bus; direct `routeCommand()` and `routeEvent()` calls remain routing-only.
+ */
+export type RepositoryRouteInvocation = "deferred";
+/**
+ * Command route calculated by a repository.
+ */
+export interface RepositoryCommandRoute<Id = unknown> {
+    /**
+     * Target entity identifier.
+     */
+    readonly entityId: Id;
+    /**
+     * Fully qualified command message type name.
+     */
+    readonly messageFullTypeName: string;
+    /**
+     * Direct repository route calculation does not invoke handlers.
+     */
+    readonly invocation: RepositoryRouteInvocation;
+}
+/**
+ * Event route calculated by a repository.
+ */
+export interface RepositoryEventRoute<Id = unknown> {
+    /**
+     * Target entity identifiers.
+     */
+    readonly entityIds: readonly Id[];
+    /**
+     * Fully qualified event message type name.
+     */
+    readonly messageFullTypeName: string;
+    /**
+     * Direct repository route calculation does not invoke handlers.
+     */
+    readonly invocation: RepositoryRouteInvocation;
+}
+/**
+ * Route calculated for one unpacked Entity state update.
+ *
+ * @internal Framework delivery metadata.
+ */
+interface RepositoryStateUpdateRoute<Id = unknown> extends RepositoryEventRoute<Id> {
+    /**
+     * Unpacked source Entity state selected from `EntityStateChanged.newState`.
+     */
+    readonly state: Message;
+    readonly subscribers: RepositoryStateSubscribers;
+}
+type EntityInboxLabel = "HANDLE_COMMAND" | "REACT_UPON_EVENT";
+type EntityInboxFollowUp = () => Promise<void>;
+type EntityInboxReplay = Promise<EntityInboxFollowUp | undefined>;
+type EntityInboxMessage = InboxMessage & {
+    readonly label: EntityInboxLabel;
+    readonly status: "TO_DELIVER";
+};
+type EntityInboxInput = Omit<InboxMessageInput, "whenReceived" | "version" | "shard"> & {
+    readonly label: EntityInboxLabel;
+    readonly status: "TO_DELIVER";
+};
+/**
+ * Describes one Aggregate or Process Manager replay target.
+ *
+ * @internal
+ */
+export interface EntityInboxTarget {
+    /**
+     * Target state type URL routed by this replay target.
+     */
+    readonly targetTypeUrl: string;
+    /**
+     * Delivery labels configured for this target.
+     */
+    readonly labels: readonly EntityInboxLabel[];
+    /**
+     * Returns after replaying a stored Entity Inbox message.
+     *
+     * @param message Supplies the durable Entity Inbox message.
+     * @param deliveryTenantId Identifies the active delivery tenant.
+     * @returns Resolves after replay, optionally with an async follow-up callback.
+     */
+    replay(message: EntityInboxMessage, deliveryTenantId?: TenantId): EntityInboxReplay;
+}
+/**
+ * Defines context-owned Entity Inbox handoff operations.
+ *
+ * @internal
+ */
+export interface EntityInbox {
+    /**
+     * Returns the context-owned target-to-shard strategy.
+     *
+     * @returns The immutable delivery strategy.
+     */
+    strategy(): import("../delivery/delivery-builder.js").DeliveryStrategy;
+    /**
+     * Delivers one durable inbox row through registered Entity Inbox targets.
+     *
+     * @param message The durable inbox row to replay.
+     * @param deliveryTenantId The tenant resolved by the delivery runtime.
+     * @returns A promise that resolves after the row is replayed.
+     */
+    replay(message: InboxMessage, deliveryTenantId?: TenantId): Promise<void>;
+    /**
+     * Writes and locally delivers one durable inbox row.
+     *
+     * @param delivery The delivery runtime that persists and replays the row.
+     * @param input The row values to persist.
+     * @param deliveryTenantId The tenant resolved by the delivery runtime.
+     * @returns The persisted inbox row.
+     */
+    receive(delivery: Delivery, input: EntityInboxInput, deliveryTenantId?: TenantId): Promise<InboxMessage>;
+    /**
+     * Writes and locally delivers durable inbox rows in input order.
+     *
+     * @param delivery The delivery runtime that persists and replays the rows.
+     * @param inputs The row values to persist.
+     * @param deliveryTenantId The tenant resolved by the delivery runtime.
+     * @returns The persisted inbox rows.
+     */
+    receiveAll(delivery: Delivery, inputs: readonly EntityInboxInput[], deliveryTenantId?: TenantId): Promise<readonly InboxMessage[]>;
+}
+/**
+ *
+ * @internal Narrow framework-only replay target for projection subscriber inbox handoff.
+ */
+type ProjectionInboxMessage = InboxMessage & {
+    readonly label: "UPDATE_SUBSCRIBER";
+    readonly status: "TO_DELIVER";
+};
+type ProjectionInboxInput = Omit<InboxMessageInput, "whenReceived" | "version"> & {
+    readonly label: "UPDATE_SUBSCRIBER";
+    readonly status: "TO_DELIVER";
+};
+/**
+ * Describes a framework-only projection inbox replay target.
+ *
+ * @internal
+ */
+export interface ProjectionInboxTarget {
+    /**
+     * Target projection state type URL routed by this replay target.
+     */
+    readonly targetTypeUrl: string;
+    /**
+     * Delivers one durable inbox event under the active delivery tenant.
+     *
+     * @param message The durable message to replay.
+     * @param deliveryTenantId The tenant resolved by the delivery runtime.
+     * @returns A promise that resolves after the message is replayed.
+     */
+    replay(message: ProjectionInboxMessage, deliveryTenantId?: TenantId): Promise<void>;
+}
+/**
+ * Defines context-owned projection subscriber inbox handoff operations.
+ *
+ * @internal
+ */
+export interface ProjectionInbox {
+    /**
+     * Delivers one durable inbox row through registered projection targets.
+     *
+     * @param message The durable inbox row to replay.
+     * @param deliveryTenantId The tenant resolved by the delivery runtime.
+     * @returns A promise that resolves after the row is replayed.
+     */
+    replay(message: InboxMessage, deliveryTenantId?: TenantId): Promise<void>;
+    /**
+     * Writes and locally delivers one durable inbox row.
+     *
+     * @param delivery The delivery runtime that persists and replays the row.
+     * @param input The row values to persist.
+     * @param deliveryTenantId The tenant resolved by the delivery runtime.
+     * @returns The persisted inbox row.
+     */
+    receive(delivery: Delivery, input: ProjectionInboxInput, deliveryTenantId?: TenantId): Promise<InboxMessage>;
+}
+/**
+ * Defines framework-only access to repository runtime state.
+ *
+ * @internal
+ */
+export interface RepositoryAccess {
+    /**
+     * Determines whether a value is a repository view.
+     *
+     * @param repository The value to inspect.
+     * @returns Whether the value belongs to a repository.
+     */
+    hasInstance(repository: unknown): repository is RepositoryView;
+    /**
+     * Returns a copy-safe repository identity snapshot.
+     *
+     * @param repository The repository to inspect.
+     * @returns The repository identity snapshot.
+     */
+    snapshot(repository: RepositoryView): RepositoryIdentitySnapshot;
+    /**
+     * Returns schemas for events that the repository can produce.
+     *
+     * @param repository the repository to inspect.
+     * @returns the produced event schemas.
+     */
+    producedEventSchemas(repository: RepositoryView): readonly MessageSchema[];
+    /**
+     * Returns the repository command dispatcher when it has command routing.
+     *
+     * @param repository The repository to inspect.
+     * @returns The command dispatcher, if present.
+     */
+    commandDispatcher(repository: RepositoryView): CommandDispatcher | undefined;
+    /**
+     * Returns the repository event dispatcher when it has event routing.
+     *
+     * @param repository The repository to inspect.
+     * @returns The event dispatcher, if present.
+     */
+    eventDispatcher(repository: RepositoryView): EventDispatcher | undefined;
+    /**
+     * Returns the repository System Event dispatcher, if present.
+     *
+     * @param repository The repository to inspect.
+     * @returns The System Event dispatcher, if present.
+     */
+    systemEventDispatcher(repository: RepositoryView): EventDispatcher | undefined;
+    /**
+     * Returns Entity state type names subscribed by the repository.
+     *
+     * @param repository The repository to inspect.
+     * @returns The subscribed Entity state type names.
+     */
+    stateSubscriptionTypes(repository: RepositoryView): readonly string[];
+    /**
+     * Calculates a Projection's internal route for an Entity state-change System event.
+     *
+     * @param repository The Projection repository to route through.
+     * @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;
+    /**
+     * Returns the Entity Inbox target configured for a repository.
+     *
+     * @param repository The repository to inspect.
+     * @returns The inbox target, if present.
+     */
+    entityInboxTarget(repository: RepositoryView): EntityInboxTarget | undefined;
+    /**
+     * Returns the projection inbox target configured for a repository.
+     *
+     * @param repository The repository to inspect.
+     * @returns The inbox target, if present.
+     */
+    projectionInboxTarget(repository: RepositoryView): ProjectionInboxTarget | undefined;
+    /**
+     * Dispatches an event directly to a projection repository.
+     *
+     * @param repository The projection repository to dispatch to.
+     * @param event The event to dispatch.
+     * @param rebuild Selects the stored-event rebuild loading mode.
+     * @returns A promise that resolves after the projection receives the event.
+     */
+    dispatchProjectionDirect(repository: RepositoryView, event: Event, rebuild?: boolean): Promise<void>;
+    /**
+     * Binds a built runtime to a repository.
+     *
+     * @param repository The repository receiving runtime services.
+     * @param runtime The context runtime to bind.
+     */
+    bindRuntime(repository: RepositoryView, runtime: RepositoryRuntime): void;
+    /**
+     * Clears runtime state and open storage handles for a repository.
+     *
+     * @param repository The repository to detach.
+     */
+    clearRuntime(repository: RepositoryView): void;
+}
+/**
+ * Exposes framework-only repository access for bounded-context assembly.
+ *
+ * @internal
+ */
+export declare const repositoryAccess: RepositoryAccess;
+interface RepositoryRuntime {
+    readonly context: StorageMode;
+    readonly storageFactory: StorageFactory;
+    readonly stand: Stand;
+    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 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>[];
+/**
+ * Internal repository handlers operations.
+ */
+declare const RepositoryHandlers: {
+    normalizeHandlers(handlersOption: RepositoryHandlersOption): readonly EntityHandlersMetadata[];
+    createCommandReactionMap(handlers: readonly EntityHandlersMetadata[]): ReadonlyMap<string, readonly RegisteredHandlerMetadata<CommandReactionHandlerMetadata>[]>;
+    createEventFilterPlans<Value extends {
+        readonly handler: {
+            readonly schema: DescriptorMessageSchema;
+            readonly where?: WhereOptions;
+        };
+    }>(byEvent: ReadonlyMap<string, readonly Value[]>, stringifiers: StringifierRegistry): ReadonlyMap<string, EventHandlerFilterPlan<Value>>;
+    forOrigin<Value extends {
+        readonly handler: {
+            readonly origin: "domestic" | "external";
+        };
+    }>(values: readonly Value[], external: boolean): readonly Value[];
+    readinessMap<Value>(schemas: readonly MessageSchema[], find: (typeName: string) => readonly Value[]): ReadonlyMap<string, readonly Value[]>;
+    handlerEmittedSchemas(handler: CommandAssignmentHandlerMetadata | CommandReactionHandlerMetadata | EventReactionHandlerMetadata): readonly DescriptorMessageSchema[];
+    isHandlersArray(value: RepositoryHandlersOption): value is readonly EntityHandlersMetadata[];
+    validateHandlers(entityType: RepositoryEntityType, metadata: EntityMetadata, handlers: readonly EntityHandlersMetadata[]): void;
+    uniqueSchemas(schemas: readonly MessageSchema[]): readonly MessageSchema[];
+    pushMapValue<Key, Value>(map: Map<Key, Value[]>, key: Key, value: Value): void;
+};
+/**
+ * Defines continuation-aware repository history caches.
+ */
+declare const repositoryHistory: {
+    /**
+     * Creates a cache that extends a repository history only when a caller requests more entries.
+     *
+     * @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.
+     * @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 cacheCompleteVersionGroups?: boolean;
+    }): {
+        readonly read: (depth: number) => Promise<readonly Entry[]>;
+        readonly clear: () => void;
+    };
+};
+/**
+ * Defines continuation-aware repository history caches.
+ */
+export declare const RepositoryHistory: Readonly<typeof repositoryHistory>;
+export {};
+//# sourceMappingURL=repository.d.ts.map