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

package/dist/repository/repository.js

@@ -0,0 +1,3510 @@
+/*
+ * Copyright 2026, CodeMatters. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+import { clone, create, ScalarType, toBinary } from "@bufbuild/protobuf";
+import { AnySchema, Int32ValueSchema, Int64ValueSchema, StringValueSchema, TimestampSchema, } from "@bufbuild/protobuf/wkt";
+import { ValidationException, RejectionThrowable, Validate, TypeUrls, AnyMessages, Identifiers, StringifierRegistry, } from "@spine-event-engine/core";
+import { CommandContextSchema, ActorContextSchema, CommandIdSchema, CommandSchema, EventContextSchema, EventIdSchema, EventSchema, MessageIdSchema, TenantIdSchema, RejectionEventContextSchema, VersionSchema, EntityOption_Kind, } from "@spine-event-engine/proto";
+import * as EntityLog from "@spine-event-engine/proto/generated/spine/system/server/entity_log_events_pb.js";
+import { EntityTypeNameSchema } from "@spine-event-engine/proto/generated/spine/system/server/entity_type_pb.js";
+import {} from "@spine-event-engine/storage";
+import { TenantBoundary } from "@spine-event-engine/storage/provider";
+import { EntityCommitStorageFactories } from "@spine-event-engine/storage/provider";
+import { CommandValidationError } from "../bus/command-errors.js";
+import { SignalPublisher } from "../runtime/signal-publisher.js";
+import { CommandRoutingInternals, } from "./command-routing.js";
+import { EventRoutingInternals } from "./event-routing.js";
+import { StateUpdateRoutingInternals, } from "./state-update-routing.js";
+import { RoutingDeclarations } from "./routing-declarations.js";
+import { EventDispatcherOriginSchemas } from "../bus/event-dispatcher-origin-schemas.js";
+import { Delivery } from "../delivery/delivery.js";
+import { commitFenced } from "./commit-fence.js";
+import { InboxTargets } from "../delivery/inbox.js";
+import { ShardIndex } from "../delivery/shard-index.js";
+import { Aggregate, ProcessManager, Projection, entityHistoryAccess, processManagerQueryAccess, transactionalEntityAccess, } from "../entity/entity.js";
+import { describeEntityMetadata, attachEntitySchema, } from "../entity/entity-metadata.js";
+import { EntityIds, EntityRecords, entityStorageDescriptor, } from "../entity/entity-storage-descriptor.js";
+import { SpecScanner } from "../entity/spec-scanner.js";
+import { CommandRegistrationReadiness, } from "../handler/command-registration-readiness.js";
+import { EventRegistrationReadiness, } from "../handler/event-registration-readiness.js";
+import { EventHandlerFilters, } from "../handler/event-handler-filter.js";
+import { SignalMetadata } from "../runtime/signal-metadata.js";
+import { QueryReader } from "../services/query-reader.js";
+import { HandlerMetadataRegistry, HandlerMetadataValues, } from "../handler/handler-metadata.js";
+import { DeclaredRejections } from "../handler/declared-rejections.js";
+import { standAccess } from "../stand/stand.js";
+import { TransitionValidationError } from "./command-errors.js";
+import { MessageIds, PrimitiveIds } from "./primitive-id.js";
+import { ImplicitRequiredIds } from "../entity/implicit-required-id.js";
+/**
+ * Describes an error raised when repository identity metadata cannot be constructed.
+ */
+export class RepositoryIdentityError extends Error {
+    // prettier-ignore
+    /**
+     * Stable code for callers/tests that need structured failure handling.
+     */
+    code;
+    /**
+     * Creates a repository identity error.
+     *
+     * @param code The stable reason for the failed identity.
+     * @param message The diagnostic message.
+     */
+    constructor(code, message) {
+        super(message);
+        this.name = "RepositoryIdentityError";
+        this.code = code;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * 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 class Repository {
+    #entityType;
+    #entityFamily;
+    #metadata;
+    #routing;
+    /**
+     * Creates repository identity for one entity family and state schema pair.
+     *
+     * @param options The entity constructor, state schema, and optional routing configuration.
+     */
+    constructor(options) {
+        if (!RepositoryIdentity.isRepositoryOptionsObject(options)) {
+            throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", "Repository options must be a non-null object with an entity type class constructor " +
+                "extending Aggregate, Projection, or ProcessManager.");
+        }
+        const entityType = RepositoryIdentity.readEntityTypeOption(options);
+        const entityTypeDisplayName = RepositoryIdentity.entityTypeName(entityType);
+        if (typeof entityType !== "function" || !RepositoryIdentity.isClassConstructor(entityType)) {
+            throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", `Repository entity type "${entityTypeDisplayName}" must be a class constructor ` +
+                "extending Aggregate, Projection, or ProcessManager.");
+        }
+        const entityFamily = RepositoryIdentity.resolveRepositoryEntityFamily(entityType);
+        if (entityFamily === undefined) {
+            throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", `Repository entity type "${entityTypeDisplayName}" must extend Aggregate, Projection, or ProcessManager.`);
+        }
+        const schema = RepositoryIdentity.readRepositorySchemaOption(options, entityTypeDisplayName, entityFamily);
+        const metadata = RepositoryIdentity.describeRepositoryEntityMetadata(entityTypeDisplayName, entityFamily, schema);
+        if (metadata.kind !== entityFamily) {
+            throw new RepositoryIdentityError("ENTITY_SCHEMA_KIND_MISMATCH", `Repository entity type "${entityTypeDisplayName}" does not match ` +
+                "the supplied state schema.");
+        }
+        if (options.stateUpdateRouting !== undefined && entityFamily !== "projection") {
+            throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", "State-update routing is supported only by Projection repositories.");
+        }
+        attachEntitySchema(entityType, schema);
+        this.#entityType = entityType;
+        this.#entityFamily = entityFamily;
+        this.#metadata = metadata;
+        this.#routing = RepositoryRoutes.createRepositoryRouting(this.#entityType, this.#entityFamily, this.#metadata, options.handlers, options.events ?? [], CommandRoutingInternals.snapshot(options.commandRouting), EventRoutingInternals.snapshot(options.eventRouting), StateUpdateRoutingInternals.snapshot(options.stateUpdateRouting), new StringifierRegistry(options.stringifierRegistry));
+        repositoryRoutings.set(this, this.#routing);
+        repositoryProducedEventSchemas.set(this, Object.freeze([...this.#routing.producedEventSchemas]));
+        repositoryHistoryConfigurations.set(this, RepositoryStorage.readHistoryConfiguration(options, this.#entityFamily));
+        repositorySnapshots.set(this, RepositoryIdentity.createRepositorySnapshot(this.#entityType, this.#entityFamily, this.#metadata));
+        repositoryDispatchers.set(this, RepositoryDispatch.createRepositoryDispatchers(this, this.#routing));
+        const entityInboxTarget = RepositoryDispatch.createEntityInboxTarget(this, this.#routing);
+        const projectionInboxTarget = RepositoryDispatch.createProjectionInboxTarget(this, this.#routing);
+        if (entityInboxTarget !== undefined) {
+            repositoryEntityInboxTargets.set(this, entityInboxTarget);
+        }
+        if (projectionInboxTarget !== undefined) {
+            repositoryProjectionInboxTargets.set(this, projectionInboxTarget);
+            repositoryProjectionDirect.set(this, RepositoryDispatch.createProjectionDirectDispatch(this, this.#routing));
+        }
+    }
+    /**
+     * Returns the entity constructor owned by this repository identity.
+     *
+     * @returns The owned entity constructor.
+     */
+    get entityType() {
+        return this.#entityType;
+    }
+    /**
+     * Returns the entity family inferred from its constructor.
+     *
+     * @returns The aggregate, projection, or process-manager family.
+     */
+    get entityFamily() {
+        return this.#entityFamily;
+    }
+    /**
+     * Returns the generated schema for this repository's entity state.
+     *
+     * @returns The owned state schema.
+     */
+    get stateSchema() {
+        return this.#metadata.schema;
+    }
+    /**
+     * 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) {
+        if (typeof enabled !== "boolean") {
+            throw new TypeError("Repository state-history switch requires a boolean.");
+        }
+        const configuration = RepositoryStorage.historyConfiguration(this);
+        if (configuration.stateHistory === enabled)
+            return;
+        configuration.stateHistory = enabled;
+        const handles = repositoryEntityHandles.get(this);
+        if (handles !== undefined) {
+            for (const handle of handles.values())
+                handle.close();
+            handles.clear();
+        }
+    }
+    /**
+     * Returns descriptor-derived metadata for the owned entity state.
+     *
+     * @returns A metadata view for the owned state.
+     */
+    get metadata() {
+        return this.#metadata;
+    }
+    /**
+     * Returns the fully qualified Protobuf name of the owned entity state.
+     *
+     * @returns The state message type name.
+     */
+    get stateFullTypeName() {
+        return this.#metadata.fullTypeName;
+    }
+    /**
+     * Returns a copy of the canonical entity ID field metadata.
+     *
+     * @returns The descriptor field used as the entity ID.
+     */
+    get idField() {
+        return RepositoryIdentity.cloneFieldMetadata(this.#metadata.idField);
+    }
+    /**
+     * Returns a copy-safe identity snapshot for builder duplicate and conflict checks.
+     *
+     * @returns An immutable snapshot of the repository identity.
+     */
+    get snapshot() {
+        return RepositoryIdentity.cloneRepositorySnapshot(RepositoryIdentity.createRepositorySnapshot(this.#entityType, this.#entityFamily, this.#metadata));
+    }
+    /**
+     * 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) {
+        return this.#routing.routeCommand(command);
+    }
+    /**
+     * 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) {
+        return this.#routing.routeEvent(event);
+    }
+}
+const repositorySnapshots = new WeakMap();
+const repositoryRoutings = new WeakMap();
+const repositoryProducedEventSchemas = new WeakMap();
+const repositoryDispatchers = new WeakMap();
+const repositoryEntityInboxTargets = new WeakMap();
+const repositoryProjectionInboxTargets = new WeakMap();
+const repositoryProjectionDirect = new WeakMap();
+const repositoryRuntimes = new WeakMap();
+const repositoryEntityHandles = new WeakMap();
+const entityStateHistoryCaches = new WeakMap();
+const repositoryHistoryConfigurations = new WeakMap();
+const repositoryDispatchGuards = new WeakMap();
+Object.freeze(Repository);
+/**
+ * Exposes framework-only repository access for bounded-context assembly.
+ *
+ * @internal
+ */
+export const repositoryAccess = Object.freeze({
+    hasInstance(repository) {
+        return repositorySnapshots.has(repository);
+    },
+    snapshot(repository) {
+        const snapshot = repositorySnapshots.get(repository);
+        if (snapshot === undefined) {
+            throw new TypeError("Repository snapshot requires a Repository instance.");
+        }
+        return RepositoryIdentity.cloneRepositorySnapshot(snapshot);
+    },
+    producedEventSchemas(repository) {
+        const schemas = repositoryProducedEventSchemas.get(repository);
+        if (schemas === undefined) {
+            throw new TypeError("Produced event schemas require a Repository instance.");
+        }
+        return schemas;
+    },
+    commandDispatcher(repository) {
+        return repositoryDispatchers.get(repository)?.command;
+    },
+    eventDispatcher(repository) {
+        return repositoryDispatchers.get(repository)?.event;
+    },
+    systemEventDispatcher(repository) {
+        return repositoryDispatchers.get(repository)?.systemEvent;
+    },
+    stateSubscriptionTypes(repository) {
+        const routing = repositoryRoutings.get(repository);
+        if (routing === undefined) {
+            throw new TypeError("State subscriptions require a Repository instance.");
+        }
+        return Object.freeze(routing.stateSchemas.map((schema) => schema.typeName));
+    },
+    routeStateUpdate(repository, event) {
+        const routing = repositoryRoutings.get(repository);
+        if (routing === undefined) {
+            throw new TypeError("State-update routing requires a Repository instance.");
+        }
+        return routing.routeStateUpdate(event);
+    },
+    entityInboxTarget(repository) {
+        return repositoryEntityInboxTargets.get(repository);
+    },
+    projectionInboxTarget(repository) {
+        return repositoryProjectionInboxTargets.get(repository);
+    },
+    dispatchProjectionDirect(repository, event, rebuild) {
+        const dispatch = repositoryProjectionDirect.get(repository);
+        if (dispatch === undefined) {
+            throw new TypeError("Direct projection dispatch requires a projection Repository instance.");
+        }
+        return dispatch(event, rebuild);
+    },
+    bindRuntime(repository, runtime) {
+        repositoryRuntimes.set(repository, Object.freeze(runtime));
+    },
+    clearRuntime(repository) {
+        repositoryRuntimes.delete(repository);
+        repositoryDispatchGuards.delete(repository);
+        const handles = repositoryEntityHandles.get(repository);
+        if (handles !== undefined) {
+            for (const handle of handles.values())
+                handle.close();
+            handles.clear();
+        }
+    },
+});
+const inboxDedupMs = 30_000;
+class AggregateExecutionSupport {
+    #repository;
+    #runtime;
+    #storageContext;
+    constructor(repository, runtime, storageContext) {
+        this.#repository = repository;
+        this.#runtime = runtime;
+        this.#storageContext = storageContext;
+    }
+    async loadAggregate(entityId) {
+        const storageInput = RepositoryStorage.entityStorageInput(this.#repository, this.#storageContext);
+        const storage = RepositoryStorage.openRepositoryEntityStorage(this.#repository, this.#runtime.storageFactory, storageInput);
+        const current = await standAccess.readCurrent(this.#runtime.stand, this.#repository.stateSchema, entityId, this.#storageContext.tenantId === undefined
+            ? {}
+            : { tenantId: this.#storageContext.tenantId });
+        const entity = this.#instantiateAggregate(entityId, current);
+        RepositoryHistoryInternals.bindEntityHistory(entity, storage, entityId, this.#repository.stateSchema);
+        return Object.freeze({
+            commits: storage.commits,
+            current: current === undefined
+                ? undefined
+                : EntityRecords.pack(this.#repository.stateSchema, entityId, current.state, current.versionMessage, { archived: current.archived, deleted: current.deleted }),
+            entity,
+            oldState: current === undefined
+                ? undefined
+                : clone(this.#repository.stateSchema, current.state),
+            states: storage.states,
+            events: storage.events,
+            version: current?.version ?? 0n,
+            storageInput,
+        });
+    }
+    normalizeProducedSignals(produced) {
+        if (produced === undefined) {
+            return Object.freeze([]);
+        }
+        if (Array.isArray(produced)) {
+            return Object.freeze(Array.from(produced));
+        }
+        return Object.freeze([produced]);
+    }
+    /**
+     * Store the current aggregate record before its diagnostic and delivery journals.
+     */
+    async persistAggregateUpdate(loaded, entityId, version, events) {
+        const lifecycle = RepositoryEntities.repositoryLifecycle(loaded.entity);
+        const state = RepositoryEntities.repositoryState(loaded.entity);
+        const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(this.#storageContext.tenantId, create(VersionSchema, { number: RepositorySignals.eventVersionNumber(version) }), lifecycle));
+        try {
+            const createdAt = events[events.length - 1]?.context?.timestamp ?? create(TimestampSchema);
+            const outcome = await loaded.commits.commit({
+                context: this.#storageContext,
+                entity: loaded.storageInput,
+                entityId,
+                ...(loaded.current === undefined ? {} : { expected: loaded.current }),
+                next: EntityRecords.pack(this.#repository.stateSchema, entityId, state, version, lifecycle),
+                ...(RepositoryStorage.historyConfiguration(this.#repository).stateHistory
+                    ? {
+                        states: [
+                            EntityRecords.pack(this.#repository.stateSchema, entityId, state, create(VersionSchema, {
+                                number: RepositorySignals.eventVersionNumber(version),
+                                timestamp: createdAt,
+                            }), lifecycle),
+                        ],
+                    }
+                    : {}),
+                diagnostics: events.map((event) => clone(EventSchema, event)),
+                events,
+            });
+            if (outcome !== "committed") {
+                deferred.cancel();
+                throw new Error("Concurrent Aggregate state commit conflict.");
+            }
+            entityStateHistoryCaches.get(loaded.entity)?.clear();
+        }
+        catch (error) {
+            deferred.cancel();
+            throw error;
+        }
+        try {
+            deferred.notify();
+        }
+        catch (error) {
+            const event = events[events.length - 1];
+            if (event !== undefined)
+                this.#runtime.publisher.reportFailure("event", event, error);
+        }
+        return true;
+    }
+    async appendDiagnosticEvent(loaded, entityId, event) {
+        await loaded.events.append(clone(EventSchema, event));
+    }
+    /**
+     * Complete persistence before scheduling best-effort stored-event dispatch.
+     */
+    async persistAggregateAndDispatch(loaded, entityId, version, events, dispatch, onPersisted) {
+        const committed = await this.persistAggregateUpdate(loaded, entityId, version, events);
+        if (!committed)
+            return () => Promise.resolve();
+        await onPersisted();
+        return async () => {
+            await Promise.all(events.map(async (event) => {
+                try {
+                    await dispatch(event);
+                }
+                catch (error) {
+                    this.#runtime.publisher.reportFailure("event", event, error);
+                }
+            }));
+        };
+    }
+    #instantiateAggregate(entityId, current) {
+        const entityType = this.#repository.entityType;
+        const options = {
+            id: entityId,
+            schema: this.#repository.stateSchema,
+            state: current?.state ?? this.#defaultState(entityId),
+            version: current?.version ?? 0n,
+        };
+        if (current !== undefined) {
+            options.lifecycle = { archived: current.archived, deleted: current.deleted };
+        }
+        return new entityType(options);
+    }
+    #defaultState(entityId) {
+        return create(this.#repository.stateSchema, {
+            [this.#repository.idField.localName]: entityId,
+        });
+    }
+}
+class AggregateCommandExecution {
+    #repository;
+    #routing;
+    #runtime;
+    #command;
+    #support;
+    constructor(repository, routing, runtime, command) {
+        this.#repository = repository;
+        this.#routing = routing;
+        this.#runtime = runtime;
+        this.#command = command;
+        this.#support = new AggregateExecutionSupport(repository, runtime, RepositoryTenants.storageContextForCommand(this.#runtime.context, this.#command));
+    }
+    async run(replayedRoute) {
+        void RepositorySignals.requireCommandId(this.#command);
+        const intake = this.#readIntake(replayedRoute);
+        if (intake === undefined)
+            return undefined;
+        return this.#runAssignee(intake);
+    }
+    #readIntake(replayedRoute) {
+        const commandMessage = EntityInvocation.requireSignalMessage(this.#command.message, "command");
+        const commandSchema = RepositoryRoutes.schemaForTypeUrl(this.#routing.commandSchemas, commandMessage.typeUrl, "command");
+        const message = EntityInvocation.unpackRequired(commandMessage, commandSchema, "command");
+        const route = replayedRoute ?? this.#repository.routeCommand(this.#command);
+        const assignee = this.#routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
+        return assignee === undefined ? undefined : Object.freeze({ message, route, assignee });
+    }
+    async #runAssignee(intake) {
+        const loaded = await this.#support.loadAggregate(intake.route.entityId);
+        this.#publishCommandDispatch(intake.route.entityId);
+        const commandContext = EntityInvocation.commandHandlerContext(this.#command);
+        let produced;
+        try {
+            produced = await this.#invokeAssignee(loaded.entity, intake.assignee.handler.methodName, intake.message, intake.assignee.handler.parameterCount, commandContext);
+        }
+        catch (error) {
+            if (!RejectionThrowable.is(error)) {
+                throw error;
+            }
+            RepositorySignals.requireDeclaredRejection(intake.assignee.handler, error);
+            return RepositorySignals.postRejectionEvent(this.#runtime, this.#repository, this.#command, intake.route.entityId, error);
+        }
+        const events = this.#requiredEvents(produced, intake.route.entityId, loaded.version);
+        return this.#persistAssigneeResult(loaded, intake.route.entityId, events);
+    }
+    #publishCommandDispatch(entityId) {
+        HandlerDispatchPublisher.command(this.#runtime, this.#repository, this.#command, entityId);
+    }
+    #requiredEvents(produced, entityId, version) {
+        const events = this.#bindProducedEvents(this.#support.normalizeProducedSignals(produced), entityId, version, true);
+        if (events.length === 0)
+            throw new Error("Repository aggregate command handlers must return at least one event.");
+        return events;
+    }
+    #persistAssigneeResult(loaded, entityId, events) {
+        const committedVersion = loaded.version + 1n;
+        return this.#support.persistAggregateAndDispatch(loaded, entityId, committedVersion, events, (event) => this.#runtime.publisher.publishCommittedEvent(event), () => {
+            if (!RepositoryEntities.repositoryChanged(loaded.entity))
+                return;
+            EntityStateChangePublisher.command(this.#runtime, this.#repository, this.#command, entityId, loaded.oldState, loaded.current === undefined
+                ? undefined
+                : {
+                    archived: loaded.current.lifecycleFlags?.archived ?? false,
+                    deleted: loaded.current.lifecycleFlags?.deleted ?? false,
+                }, RepositoryEntities.repositoryState(loaded.entity), RepositoryEntities.repositoryLifecycle(loaded.entity), RepositorySignals.eventVersionNumber(committedVersion));
+        });
+    }
+    async #invokeAssignee(entity, methodName, message, parameterCount, context) {
+        transactionalEntityAccess.start(entity);
+        try {
+            const produced = await EntityInvocation.invokeEntityMethod(entity, methodName, message, parameterCount, context);
+            const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
+            if (commit.status === "rejected") {
+                throw new TransitionValidationError(commit.validation.error);
+            }
+            return produced;
+        }
+        catch (error) {
+            transactionalEntityAccess.rollback(entity);
+            throw error;
+        }
+    }
+    #bindProducedEvents(produced, entityId, lastVersion, allowEnvelopes) {
+        const dispatchVersion = lastVersion;
+        return Object.freeze(produced.map((signal) => this.#bindProducedEvent(signal, entityId, dispatchVersion, allowEnvelopes)));
+    }
+    #bindProducedEvent(signal, entityId, version, allowEnvelopes) {
+        const metadata = this.#runtime.signalMetadata.eventFromCommand(this.#command, {
+            version: RepositorySignals.eventVersionNumber(version),
+        });
+        const bound = allowEnvelopes && EntityInvocation.isEventEnvelope(signal)
+            ? clone(EventSchema, signal)
+            : this.#packDomainEvent(signal, metadata);
+        bound.context = RepositorySignals.eventContextWithProducer(metadata.context, this.#repository, entityId);
+        return bound;
+    }
+    #packDomainEvent(message, metadata) {
+        const typeName = EntityInvocation.messageTypeName(message);
+        const schema = this.#routing.producedEventSchemas.find((candidate) => candidate.typeName === typeName);
+        if (schema === undefined) {
+            throw new Error(`Repository aggregate execution cannot pack event message "${typeName}".`);
+        }
+        return create(EventSchema, {
+            id: metadata.id,
+            message: AnyMessages.pack(schema, message),
+            context: metadata.context,
+        });
+    }
+}
+class AggregateEventExecution {
+    #repository;
+    #routing;
+    #runtime;
+    #event;
+    #support;
+    constructor(repository, routing, runtime, event) {
+        this.#repository = repository;
+        this.#routing = routing;
+        this.#runtime = runtime;
+        this.#event = event;
+        this.#support = new AggregateExecutionSupport(repository, runtime, RepositoryTenants.storageContextForEvent(this.#runtime.context, this.#event));
+    }
+    async runTarget(entityId, acceptedRoute) {
+        const intake = this.#readIntake(acceptedRoute);
+        if (intake.reactors.length === 0) {
+            return;
+        }
+        await this.#executeEntity(entityId, intake);
+    }
+    #readIntake(acceptedRoute) {
+        const eventMessage = EntityInvocation.requireSignalMessage(this.#event.message, "event");
+        const eventSchema = RepositoryRoutes.schemaForTypeUrl(this.#routing.eventSchemas, eventMessage.typeUrl, "event");
+        const message = EntityInvocation.unpackRequired(eventMessage, eventSchema, "event");
+        const route = acceptedRoute;
+        const reactors = this.#routing
+            .eventReactors(route.messageFullTypeName, message, this.#event.context?.external === true)
+            .filter((reactor) => RepositoryHandlers.handlerEmittedSchemas(reactor.handler).length > 0);
+        return Object.freeze({
+            message,
+            route,
+            reactors: Object.freeze([...reactors]),
+        });
+    }
+    async #executeEntity(entityId, intake) {
+        const loaded = await this.#support.loadAggregate(entityId);
+        const produced = await this.#invokeHandlers(entityId, loaded, intake);
+        await this.#persistProducedEvents(loaded, entityId, produced);
+        await this.#support.appendDiagnosticEvent(loaded, entityId, DispatchGuards.guardedJournalEvent(this.#repository, this.#event, entityId));
+        return undefined;
+    }
+    async #persistProducedEvents(loaded, entityId, produced) {
+        if (produced.length === 0)
+            return;
+        const dispatch = await this.#support.persistAggregateAndDispatch(loaded, entityId, loaded.version + 1n, produced, (event) => this.#runtime.publisher.publishReactorEvent(event), () => {
+            this.#publishStateChange(loaded, entityId);
+        });
+        void dispatch();
+    }
+    #publishStateChange(loaded, entityId) {
+        if (!RepositoryEntities.repositoryChanged(loaded.entity))
+            return;
+        EntityStateChangePublisher.event(this.#runtime, this.#repository, this.#event, entityId, loaded.oldState, this.#lifecycleSnapshot(loaded), RepositoryEntities.repositoryState(loaded.entity), RepositoryEntities.repositoryLifecycle(loaded.entity), RepositorySignals.eventVersionNumber(loaded.version + 1n));
+    }
+    #lifecycleSnapshot(loaded) {
+        return loaded.current === undefined
+            ? undefined
+            : {
+                archived: loaded.current.lifecycleFlags?.archived ?? false,
+                deleted: loaded.current.lifecycleFlags?.deleted ?? false,
+            };
+    }
+    async #invokeHandlers(entityId, loaded, intake) {
+        const eventContext = EntityInvocation.eventHandlerContext(this.#event);
+        const events = [];
+        transactionalEntityAccess.start(loaded.entity);
+        try {
+            await this.#invokeReactors(entityId, loaded, intake, eventContext, events);
+            await this.#commitEntity(loaded.entity);
+            return Object.freeze(events);
+        }
+        catch (error) {
+            transactionalEntityAccess.rollback(loaded.entity);
+            throw error;
+        }
+    }
+    async #invokeReactors(entityId, loaded, intake, eventContext, events) {
+        if (intake.reactors.length > 0)
+            HandlerDispatchPublisher.reactor(this.#runtime, this.#repository, this.#event, entityId);
+        for (const reactor of intake.reactors) {
+            const produced = await EntityInvocation.invokeEntityMethod(loaded.entity, reactor.handler.methodName, intake.message, reactor.handler.parameterCount, eventContext);
+            events.push(...this.#bindProducedEvents(this.#support.normalizeProducedSignals(produced), entityId, loaded.version));
+        }
+    }
+    async #commitEntity(entity) {
+        const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
+        if (commit.status === "rejected")
+            throw new TransitionValidationError(commit.validation.error);
+    }
+    #bindProducedEvents(produced, entityId, lastVersion) {
+        const version = lastVersion;
+        return Object.freeze(produced.map((signal) => this.#bindProducedEvent(signal, entityId, version)));
+    }
+    #bindProducedEvent(signal, entityId, version) {
+        const typeName = EntityInvocation.messageTypeName(signal);
+        const schema = this.#routing.producedEventSchemas.find((candidate) => candidate.typeName === typeName);
+        if (schema === undefined) {
+            throw new Error(`Repository aggregate execution cannot pack event message "${typeName}".`);
+        }
+        const metadata = this.#runtime.signalMetadata.eventFromEvent(this.#event, {
+            version: RepositorySignals.eventVersionNumber(version),
+        });
+        return create(EventSchema, {
+            id: metadata.id,
+            message: AnyMessages.pack(schema, signal),
+            context: RepositorySignals.eventContextWithProducer(metadata.context, this.#repository, entityId),
+        });
+    }
+}
+class ProjectionEventExecution {
+    #repository;
+    #routing;
+    #runtime;
+    #event;
+    #rebuild;
+    constructor(repository, routing, runtime, event, rebuild = false) {
+        this.#repository = repository;
+        this.#routing = routing;
+        this.#runtime = runtime;
+        this.#event = event;
+        this.#rebuild = rebuild;
+    }
+    static async runStateTarget(repository, routing, runtime, event, entityId, route, subscribers) {
+        const execution = new ProjectionEventExecution(repository, routing, runtime, event);
+        await execution.#executeStateTarget(entityId, route.state, subscribers);
+    }
+    async run(acceptedRoute) {
+        const intake = this.#readIntake(acceptedRoute);
+        if (intake.subscribers.length === 0) {
+            return;
+        }
+        for (const entityId of intake.route.entityIds) {
+            await InboxHandoff.handoffProjectionEvent(this.#repository, this.#runtime, this.#event, entityId);
+        }
+    }
+    async runTarget(entityId, acceptedRoute) {
+        const intake = this.#readIntake(acceptedRoute);
+        if (intake.subscribers.length === 0) {
+            return;
+        }
+        await this.#executeTarget(entityId, intake.subscribers);
+    }
+    async runDirect(acceptedRoute) {
+        const intake = this.#readIntake(acceptedRoute);
+        if (intake.subscribers.length === 0) {
+            return;
+        }
+        for (const entityId of intake.route.entityIds) {
+            await this.#executeTarget(entityId, intake.subscribers);
+        }
+    }
+    async #executeTarget(entityId, subscribers) {
+        const packedMessage = EntityInvocation.requireSignalMessage(this.#event.message, "event");
+        const tenantOptions = RepositoryTenants.standTenantOptions(this.#runtime.context, this.#event);
+        const mode = this.#rebuild ? "rebuild" : "stored";
+        const loaded = await this.#loadProjection(entityId, tenantOptions, mode);
+        HandlerDispatchPublisher.subscriber(this.#runtime, this.#repository, this.#event, entityId);
+        await this.#invokeSubscribers(loaded.entity, subscribers, packedMessage);
+        await this.#storeIfChanged(loaded, tenantOptions, loaded.current === undefined
+            ? undefined
+            : EntityRecords.unpack(this.#repository.stateSchema, loaded.current).state, mode);
+    }
+    async #executeStateTarget(entityId, state, subscribers) {
+        const tenantOptions = RepositoryTenants.standTenantOptions(this.#runtime.context, this.#event);
+        const loaded = await this.#loadProjection(entityId, tenantOptions, "stored");
+        await this.#invokeStateSubscribers(loaded.entity, subscribers, state);
+        await this.#storeIfChanged(loaded, tenantOptions, loaded.current === undefined
+            ? undefined
+            : EntityRecords.unpack(this.#repository.stateSchema, loaded.current).state, "stored");
+    }
+    #readIntake(acceptedRoute) {
+        const route = acceptedRoute ?? this.#repository.routeEvent(this.#event);
+        const packedMessage = EntityInvocation.requireSignalMessage(this.#event.message, "event");
+        const eventSchema = RepositoryRoutes.schemaForTypeUrl(this.#routing.eventSchemas, packedMessage.typeUrl, "event");
+        const message = EntityInvocation.unpackRequired(packedMessage, eventSchema, "event");
+        const subscribers = this.#routing.eventSubscribers(route.messageFullTypeName, message, this.#event.context?.external === true);
+        return Object.freeze({
+            route,
+            subscribers,
+        });
+    }
+    async #storeIfChanged(loaded, tenantOptions, oldState, mode) {
+        if (!RepositoryEntities.repositoryChanged(loaded.entity)) {
+            return;
+        }
+        const entityId = loaded.entity.id;
+        const state = RepositoryEntities.repositoryState(loaded.entity);
+        const version = BigInt(this.#event.context?.version?.number ?? 0);
+        const lifecycle = RepositoryEntities.repositoryLifecycle(loaded.entity);
+        const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(tenantOptions.tenantId, this.#event.context?.version, lifecycle));
+        try {
+            const outcome = await loaded.commits.commit({
+                context: loaded.storageInput.context,
+                entity: loaded.storageInput,
+                entityId,
+                ...(loaded.current === undefined ? {} : { expected: loaded.current }),
+                next: EntityRecords.pack(this.#repository.stateSchema, entityId, state, this.#event.context?.version ?? version, lifecycle),
+                ...(RepositoryStorage.historyConfiguration(this.#repository).stateHistory
+                    ? {
+                        states: [
+                            EntityRecords.pack(this.#repository.stateSchema, entityId, state, this.#event.context?.version ?? version, lifecycle),
+                        ],
+                    }
+                    : {}),
+            });
+            if (outcome !== "committed") {
+                deferred.cancel();
+                throw new Error("Concurrent Projection state commit conflict.");
+            }
+        }
+        catch (error) {
+            deferred.cancel();
+            throw error;
+        }
+        try {
+            deferred.notify();
+        }
+        catch (error) {
+            this.#runtime.publisher.reportFailure("event", this.#event, error);
+        }
+        EntityStateChangePublisher.event(this.#runtime, this.#repository, this.#event, entityId, oldState, mode === "rebuild"
+            ? lifecycle
+            : loaded.current === undefined
+                ? undefined
+                : {
+                    archived: loaded.current.lifecycleFlags?.archived ?? false,
+                    deleted: loaded.current.lifecycleFlags?.deleted ?? false,
+                }, state, lifecycle, this.#event.context?.version?.number ?? 0);
+    }
+    async #invokeSubscribers(entity, subscribers, packedMessage) {
+        transactionalEntityAccess.start(entity);
+        try {
+            for (const subscriber of subscribers) {
+                const subscriberMessage = EntityInvocation.unpackRequired(packedMessage, subscriber.handler.schema, "event");
+                const eventContext = EntityInvocation.eventHandlerContext(this.#event);
+                await EntityInvocation.invokeEntityMethod(entity, subscriber.handler.methodName, subscriberMessage, subscriber.handler.parameterCount, eventContext);
+            }
+            const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
+            if (commit.status === "rejected") {
+                throw new TransitionValidationError(commit.validation.error);
+            }
+        }
+        catch (error) {
+            transactionalEntityAccess.rollback(entity);
+            throw error;
+        }
+    }
+    async #invokeStateSubscribers(entity, subscribers, state) {
+        transactionalEntityAccess.start(entity);
+        try {
+            for (const subscriber of subscribers) {
+                const context = EntityInvocation.eventHandlerContext(this.#event);
+                await EntityInvocation.invokeEntityMethod(entity, subscriber.handler.methodName, state, subscriber.handler.parameterCount, context);
+            }
+            const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
+            if (commit.status === "rejected")
+                throw new TransitionValidationError(commit.validation.error);
+        }
+        catch (error) {
+            transactionalEntityAccess.rollback(entity);
+            throw error;
+        }
+    }
+    async #loadProjection(entityId, options, mode) {
+        const stored = await standAccess.readCurrent(this.#runtime.stand, this.#repository.stateSchema, entityId, options);
+        const entityType = this.#repository.entityType;
+        const entity = new entityType({
+            id: entityId,
+            schema: this.#repository.stateSchema,
+            state: stored === undefined || (mode === "rebuild" && stored.deleted)
+                ? this.#defaultState(entityId)
+                : stored.state,
+            version: mode === "rebuild" && stored?.deleted
+                ? 0
+                : RepositoryStand.projectionVersion(stored?.version),
+            lifecycle: mode === "rebuild" && stored?.deleted
+                ? { archived: false, deleted: false }
+                : { archived: stored?.archived ?? false, deleted: stored?.deleted ?? false },
+        });
+        const storageInput = RepositoryStorage.entityStorageInput(this.#repository, RepositoryTenants.storageContextForTenant(this.#runtime.context, options.tenantId));
+        const storage = RepositoryStorage.openRepositoryEntityStorage(this.#repository, this.#runtime.storageFactory, storageInput);
+        RepositoryHistoryInternals.bindEntityHistory(entity, storage, entityId, this.#repository.stateSchema);
+        return Object.freeze({
+            commits: storage.commits,
+            current: stored === undefined
+                ? undefined
+                : EntityRecords.pack(this.#repository.stateSchema, entityId, stored.state, stored.versionMessage, { archived: stored.archived, deleted: stored.deleted }),
+            entity,
+            storageInput,
+        });
+    }
+    #defaultState(entityId) {
+        return create(this.#repository.stateSchema, {
+            [this.#repository.idField.localName]: entityId,
+        });
+    }
+}
+const ProcessManagerQueries = Object.freeze({
+    bind(entity, runtime, actorContext, tenantId) {
+        const context = actorContext === undefined
+            ? create(ActorContextSchema)
+            : clone(ActorContextSchema, actorContext);
+        if (tenantId !== undefined) {
+            context.tenantId = RepositoryTenants.require(tenantId);
+        }
+        return processManagerQueryAccess.bind(entity, async (plan, schema, query) => {
+            const results = await QueryReader.read(runtime.stand, schema, plan, tenantId, 10_000, query);
+            return Object.freeze(results.map((result) => clone(schema, result.state)));
+        }, context);
+    },
+});
+class ProcessManagerExecutionSupport {
+    #repository;
+    #runtime;
+    constructor(repository, runtime) {
+        this.#repository = repository;
+        this.#runtime = runtime;
+    }
+    normalizeProducedSignals(produced) {
+        if (produced === undefined) {
+            return Object.freeze([]);
+        }
+        if (Array.isArray(produced)) {
+            return Object.freeze(Array.from(produced));
+        }
+        return Object.freeze([produced]);
+    }
+    async load(entityId, options) {
+        const stored = await standAccess.readCurrent(this.#runtime.stand, this.#repository.stateSchema, entityId, options);
+        const entityType = this.#repository.entityType;
+        const entity = new entityType({
+            id: entityId,
+            schema: this.#repository.stateSchema,
+            state: stored === undefined ? this.#defaultState(entityId) : stored.state,
+            version: RepositoryStand.projectionVersion(stored?.version),
+            lifecycle: { archived: stored?.archived ?? false, deleted: stored?.deleted ?? false },
+        });
+        const storageInput = RepositoryStorage.entityStorageInput(this.#repository, RepositoryTenants.storageContextForTenant(this.#runtime.context, options.tenantId));
+        const storage = RepositoryStorage.openRepositoryEntityStorage(this.#repository, this.#runtime.storageFactory, storageInput);
+        RepositoryHistoryInternals.bindEntityHistory(entity, storage, entityId, this.#repository.stateSchema);
+        return Object.freeze({
+            commits: storage.commits,
+            current: stored === undefined
+                ? undefined
+                : EntityRecords.pack(this.#repository.stateSchema, entityId, stored.state, stored.versionMessage, { archived: stored.archived, deleted: stored.deleted }),
+            entity,
+            storageInput,
+        });
+    }
+    async commit(loaded, options, createdAt, events) {
+        const changed = RepositoryEntities.repositoryChanged(loaded.entity);
+        if (!changed && events.length === 0)
+            return true;
+        const entityId = loaded.entity.id;
+        const state = RepositoryEntities.repositoryState(loaded.entity);
+        const lifecycle = RepositoryEntities.repositoryLifecycle(loaded.entity);
+        const version = changed
+            ? BigInt(RepositoryStand.processManagerVersion(loaded.entity))
+            : BigInt(loaded.current?.version?.number ?? 0);
+        const deferred = changed
+            ? await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(options.tenantId, create(VersionSchema, { number: Number(version) }), lifecycle))
+            : undefined;
+        try {
+            const history = RepositoryStorage.historyConfiguration(this.#repository);
+            const outcome = await loaded.commits.commit({
+                context: loaded.storageInput.context,
+                entity: loaded.storageInput,
+                entityId,
+                ...(loaded.current === undefined ? {} : { expected: loaded.current }),
+                next: EntityRecords.pack(this.#repository.stateSchema, entityId, state, version, lifecycle),
+                ...(changed && history.stateHistory
+                    ? {
+                        states: [
+                            EntityRecords.pack(this.#repository.stateSchema, entityId, state, create(VersionSchema, { number: Number(version), timestamp: createdAt }), lifecycle),
+                        ],
+                    }
+                    : {}),
+                ...(history.processManagerEventHistory
+                    ? {
+                        diagnostics: events.map((event) => clone(EventSchema, event)),
+                    }
+                    : {}),
+            });
+            if (outcome !== "committed") {
+                deferred?.cancel();
+                throw new Error("Concurrent Process Manager state commit conflict.");
+            }
+            entityStateHistoryCaches.get(loaded.entity)?.clear();
+        }
+        catch (error) {
+            deferred?.cancel();
+            throw error;
+        }
+        try {
+            deferred?.notify();
+        }
+        catch (error) {
+            this.#runtime.publisher.reportFailure("event", events[events.length - 1] ?? create(EventSchema), error);
+        }
+        return true;
+    }
+    #defaultState(entityId) {
+        return create(this.#repository.stateSchema, {
+            [this.#repository.idField.localName]: entityId,
+        });
+    }
+}
+class ProcessManagerCommandExecution {
+    #repository;
+    #routing;
+    #runtime;
+    #command;
+    #support;
+    constructor(repository, routing, runtime, command) {
+        this.#repository = repository;
+        this.#routing = routing;
+        this.#runtime = runtime;
+        this.#command = command;
+        this.#support = new ProcessManagerExecutionSupport(repository, runtime);
+    }
+    async run(replayedRoute) {
+        RepositorySignals.requireCommandId(this.#command);
+        const intake = this.#readIntake(replayedRoute);
+        if (intake === undefined)
+            return undefined;
+        const tenantOptions = RepositoryTenants.commandStandOptions(this.#runtime.context, this.#command);
+        const loaded = await this.#support.load(intake.route.entityId, tenantOptions);
+        this.#publishDispatch(intake.route.entityId);
+        try {
+            const produced = await this.#invoke(loaded.entity, intake.assignee, intake.message, tenantOptions.tenantId);
+            return await this.#commitAndPublish(loaded, tenantOptions, intake, produced);
+        }
+        catch (error) {
+            if (!RejectionThrowable.is(error))
+                throw error;
+            RepositorySignals.requireDeclaredRejection(intake.assignee.handler, error);
+            return RepositorySignals.postRejectionEvent(this.#runtime, this.#repository, this.#command, intake.route.entityId, error);
+        }
+    }
+    #publishDispatch(entityId) {
+        HandlerDispatchPublisher.command(this.#runtime, this.#repository, this.#command, entityId);
+    }
+    #readIntake(replayedRoute) {
+        const commandMessage = EntityInvocation.requireSignalMessage(this.#command.message, "command");
+        const commandSchema = RepositoryRoutes.schemaForTypeUrl(this.#routing.commandSchemas, commandMessage.typeUrl, "command");
+        const message = EntityInvocation.unpackRequired(commandMessage, commandSchema, "command");
+        const route = replayedRoute ?? this.#repository.routeCommand(this.#command);
+        const assignee = this.#routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
+        return assignee === undefined ? undefined : Object.freeze({ assignee, message, route });
+    }
+    async #commitAndPublish(loaded, tenantOptions, intake, producedSignals) {
+        const commands = this.#commandOutputs(intake.assignee, producedSignals);
+        const events = this.#eventOutputs(intake.assignee, producedSignals, intake.route.entityId);
+        const committed = await this.#support.commit(loaded, tenantOptions, RepositorySignals.executionTimestamp(), events);
+        if (!committed)
+            return undefined;
+        this.#publishChangedState(loaded, intake.route.entityId);
+        this.#postEvents(events);
+        return commands.length === 0
+            ? undefined
+            : async () => {
+                await this.#postCommands(commands, this.#command);
+            };
+    }
+    #commandOutputs(assignee, produced) {
+        if (assignee.handler.kind !== "command-substitution")
+            return Object.freeze([]);
+        const commands = this.#bindProducedCommands(produced);
+        if (commands.length === 0) {
+            throw new Error("Repository Process Manager command substitutions must return at least one command.");
+        }
+        return commands;
+    }
+    #eventOutputs(assignee, produced, entityId) {
+        return assignee.handler.kind === "command-assignment"
+            ? this.#bindProducedEvents(produced, entityId)
+            : Object.freeze([]);
+    }
+    #publishChangedState(loaded, entityId) {
+        if (RepositoryEntities.repositoryChanged(loaded.entity)) {
+            EntityStateChangePublisher.command(this.#runtime, this.#repository, this.#command, entityId, loaded.current === undefined
+                ? undefined
+                : EntityRecords.unpack(this.#repository.stateSchema, loaded.current).state, loaded.current === undefined
+                ? undefined
+                : {
+                    archived: loaded.current.lifecycleFlags?.archived ?? false,
+                    deleted: loaded.current.lifecycleFlags?.deleted ?? false,
+                }, RepositoryEntities.repositoryState(loaded.entity), RepositoryEntities.repositoryLifecycle(loaded.entity), RepositoryStand.processManagerVersion(loaded.entity));
+        }
+    }
+    async #invoke(entity, assignee, message, tenantId) {
+        const releaseQuery = ProcessManagerQueries.bind(entity, this.#runtime, this.#command.context?.actorContext, tenantId);
+        try {
+            return await this.#invokeCommandHandler(entity, assignee, message);
+        }
+        finally {
+            releaseQuery();
+        }
+    }
+    async #invokeCommandHandler(entity, assignee, message) {
+        transactionalEntityAccess.start(entity);
+        try {
+            const produced = await EntityInvocation.invokeEntityMethod(entity, assignee.handler.methodName, message, assignee.handler.parameterCount, EntityInvocation.commandHandlerContext(this.#command));
+            const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
+            if (commit.status === "rejected") {
+                throw new TransitionValidationError(commit.validation.error);
+            }
+            return this.#support.normalizeProducedSignals(produced);
+        }
+        catch (error) {
+            transactionalEntityAccess.rollback(entity);
+            throw error;
+        }
+    }
+    #bindProducedEvents(produced, entityId) {
+        let sequence = 0;
+        return Object.freeze(produced.map((signal) => {
+            sequence += 1;
+            return this.#bindProducedEvent(signal, entityId, sequence);
+        }));
+    }
+    #bindProducedEvent(signal, entityId, sequence) {
+        const typeName = EntityInvocation.messageTypeName(signal);
+        const schema = this.#routing.producedEventSchemas.find((candidate) => candidate.typeName === typeName);
+        if (schema === undefined) {
+            throw new Error(`Repository process-manager execution cannot pack event message "${typeName}".`);
+        }
+        const metadata = this.#runtime.signalMetadata.eventFromCommand(this.#command, {
+            version: RepositoryStand.processManagerProducedVersion(sequence),
+        });
+        return create(EventSchema, {
+            id: metadata.id,
+            message: AnyMessages.pack(schema, signal),
+            context: RepositorySignals.eventContextWithProducer(metadata.context, this.#repository, entityId),
+        });
+    }
+    #bindProducedCommands(produced) {
+        return Object.freeze(produced.map((signal) => {
+            const typeName = EntityInvocation.messageTypeName(signal);
+            const schema = this.#routing.producedCommandSchemas.find((candidate) => candidate.typeName === typeName);
+            if (schema === undefined) {
+                throw new Error(`Repository process-manager execution cannot pack command message "${typeName}".`);
+            }
+            const metadata = this.#runtime.signalMetadata.commandFromCommand(this.#command);
+            return create(CommandSchema, {
+                id: metadata.id,
+                message: AnyMessages.pack(schema, signal),
+                context: metadata.context,
+            });
+        }));
+    }
+    async #postCommands(commands, source) {
+        void source;
+        for (const command of commands) {
+            await this.#runtime.publisher.publishCommand(command);
+        }
+    }
+    #postEvents(events) {
+        for (const event of events) {
+            // spine-log-boundary: server.repository_event_follow_up
+            void this.#runtime.publisher.publishEvent(event);
+        }
+    }
+}
+class ProcessManagerEventExecution {
+    #repository;
+    #routing;
+    #runtime;
+    #event;
+    #support;
+    constructor(repository, routing, runtime, event) {
+        this.#repository = repository;
+        this.#routing = routing;
+        this.#runtime = runtime;
+        this.#event = event;
+        this.#support = new ProcessManagerExecutionSupport(repository, runtime);
+    }
+    async run(acceptedRoute) {
+        const intake = this.#readIntake(acceptedRoute);
+        if (intake.reactors.length === 0 && intake.commanders.length === 0) {
+            return;
+        }
+        this.#validateSourceEventIdForFollowUps(intake);
+        if (intake.route.entityIds.length === 1) {
+            await InboxHandoff.handoffPmEvent(this.#repository, this.#runtime, this.#event, intake.route.entityIds[0]);
+            return;
+        }
+        await InboxHandoff.handoffPmEvents(this.#repository, this.#runtime, this.#event, intake.route.entityIds);
+    }
+    async runTarget(entityId, acceptedRoute) {
+        const intake = this.#readIntake(acceptedRoute);
+        if (intake.reactors.length === 0 && intake.commanders.length === 0) {
+            return;
+        }
+        this.#validateSourceEventIdForFollowUps(intake);
+        await DispatchGuards.guardedEntityEventDispatch(this.#repository, this.#runtime, this.#event, entityId, async () => {
+            await this.#executeEntity(entityId, intake);
+        });
+    }
+    #readIntake(acceptedRoute) {
+        const eventMessage = EntityInvocation.requireSignalMessage(this.#event.message, "event");
+        const eventSchema = RepositoryRoutes.schemaForTypeUrl(this.#routing.eventSchemas, eventMessage.typeUrl, "event");
+        const message = EntityInvocation.unpackRequired(eventMessage, eventSchema, "event");
+        const route = acceptedRoute;
+        const reactors = this.#routing.eventReactors(route.messageFullTypeName, message, this.#event.context?.external === true);
+        const commanders = this.#routing.commandReactions(route.messageFullTypeName, message, this.#event.context?.external === true);
+        return Object.freeze({
+            message,
+            route,
+            reactors: Object.freeze([...reactors]),
+            commanders,
+        });
+    }
+    async #executeEntity(entityId, intake) {
+        const tenantOptions = RepositoryTenants.standTenantOptions(this.#runtime.context, this.#event);
+        const loaded = await this.#support.load(entityId, tenantOptions);
+        const produced = await this.#invokeHandlers(entityId, loaded.entity, intake, tenantOptions.tenantId);
+        const events = this.#bindProducedEvents(produced.events, entityId);
+        const diagnostics = [
+            DispatchGuards.guardedJournalEvent(this.#repository, this.#event, entityId),
+            ...events,
+        ];
+        const committed = await this.#support.commit(loaded, tenantOptions, this.#event.context?.timestamp ?? create(TimestampSchema), diagnostics);
+        if (!committed)
+            return;
+        this.#publishChangedState(loaded, entityId);
+        this.#postEvents(events);
+        await this.#postCommands(this.#bindProducedCommands(produced.commands));
+    }
+    #publishChangedState(loaded, entityId) {
+        if (!RepositoryEntities.repositoryChanged(loaded.entity))
+            return;
+        EntityStateChangePublisher.event(this.#runtime, this.#repository, this.#event, entityId, loaded.current === undefined
+            ? undefined
+            : EntityRecords.unpack(this.#repository.stateSchema, loaded.current).state, loaded.current === undefined
+            ? undefined
+            : {
+                archived: loaded.current.lifecycleFlags?.archived ?? false,
+                deleted: loaded.current.lifecycleFlags?.deleted ?? false,
+            }, RepositoryEntities.repositoryState(loaded.entity), RepositoryEntities.repositoryLifecycle(loaded.entity), RepositoryStand.processManagerVersion(loaded.entity));
+    }
+    #validateSourceEventIdForFollowUps(intake) {
+        const emitsFollowUpEvents = intake.reactors.some((reactor) => RepositoryHandlers.handlerEmittedSchemas(reactor.handler).length > 0);
+        if (!emitsFollowUpEvents && intake.commanders.length === 0) {
+            return;
+        }
+        void this.#runtime.signalMetadata.originFromEvent(this.#event);
+    }
+    async #invokeHandlers(entityId, entity, intake, tenantId) {
+        const eventContext = EntityInvocation.eventHandlerContext(this.#event);
+        const commands = [];
+        const events = [];
+        const releaseQuery = ProcessManagerQueries.bind(entity, this.#runtime, this.#runtime.signalMetadata.originFromEvent(this.#event).actorContext, tenantId);
+        transactionalEntityAccess.start(entity);
+        try {
+            await this.#invokeEventHandlers(entityId, entity, intake, eventContext, events, commands);
+            await this.#commitEntity(entity);
+            return Object.freeze({
+                commands: Object.freeze(commands),
+                events: Object.freeze(events),
+            });
+        }
+        catch (error) {
+            transactionalEntityAccess.rollback(entity);
+            throw error;
+        }
+        finally {
+            releaseQuery();
+        }
+    }
+    async #invokeEventHandlers(entityId, entity, intake, context, events, commands) {
+        if (intake.reactors.length > 0)
+            HandlerDispatchPublisher.reactor(this.#runtime, this.#repository, this.#event, entityId);
+        await this.#invokeHandlersInto(entity, intake.reactors, intake.message, context, events);
+        await this.#invokeHandlersInto(entity, intake.commanders, intake.message, context, commands);
+    }
+    async #invokeHandlersInto(entity, handlers, message, context, output) {
+        for (const handler of handlers) {
+            const produced = await EntityInvocation.invokeEntityMethod(entity, handler.handler.methodName, message, handler.handler.parameterCount, context);
+            output.push(...this.#support.normalizeProducedSignals(produced));
+        }
+    }
+    async #commitEntity(entity) {
+        const commit = await commitFenced(entity, (current) => transactionalEntityAccess.commit(current));
+        if (commit.status === "rejected")
+            throw new TransitionValidationError(commit.validation.error);
+    }
+    #bindProducedEvents(produced, entityId) {
+        let sequence = 0;
+        return Object.freeze(produced.map((signal) => {
+            sequence += 1;
+            return this.#bindProducedEvent(signal, entityId, sequence);
+        }));
+    }
+    #bindProducedEvent(signal, entityId, sequence) {
+        const typeName = EntityInvocation.messageTypeName(signal);
+        const schema = this.#routing.producedEventSchemas.find((candidate) => candidate.typeName === typeName);
+        if (schema === undefined) {
+            throw new Error(`Repository process-manager execution cannot pack event message "${typeName}".`);
+        }
+        const metadata = this.#runtime.signalMetadata.eventFromEvent(this.#event, {
+            version: RepositoryStand.processManagerProducedVersion(sequence),
+        });
+        return create(EventSchema, {
+            id: metadata.id,
+            message: AnyMessages.pack(schema, signal),
+            context: RepositorySignals.eventContextWithProducer(metadata.context, this.#repository, entityId),
+        });
+    }
+    #bindProducedCommands(produced) {
+        return Object.freeze(produced.map((signal) => {
+            const typeName = EntityInvocation.messageTypeName(signal);
+            const schema = this.#routing.producedCommandSchemas.find((candidate) => candidate.typeName === typeName);
+            if (schema === undefined) {
+                throw new Error(`Repository process-manager execution cannot pack command message "${typeName}".`);
+            }
+            const metadata = this.#runtime.signalMetadata.commandFromEvent(this.#event);
+            return create(CommandSchema, {
+                id: metadata.id,
+                message: AnyMessages.pack(schema, signal),
+                context: metadata.context,
+            });
+        }));
+    }
+    async #postCommands(commands) {
+        for (const command of commands) {
+            await this.#runtime.publisher.publishCommand(command);
+        }
+    }
+    #postEvents(events) {
+        for (const event of events) {
+            // spine-log-boundary: server.process_manager_event_follow_up
+            void this.#runtime.publisher.publishEvent(event);
+        }
+    }
+}
+/**
+ * Internal repository identity operations.
+ */
+const RepositoryIdentity = {
+    createRepositorySnapshot(entityType, entityFamily, metadata) {
+        const metadataCopy = RepositoryIdentity.cloneEntityMetadata(metadata);
+        return Object.freeze({
+            entityType,
+            entityFamily,
+            stateSchema: metadataCopy.schema,
+            metadata: metadataCopy,
+            stateFullTypeName: metadataCopy.fullTypeName,
+            idField: RepositoryIdentity.cloneFieldMetadata(metadataCopy.idField),
+        });
+    },
+    cloneRepositorySnapshot(snapshot) {
+        const metadata = RepositoryIdentity.cloneEntityMetadata(snapshot.metadata);
+        return Object.freeze({
+            entityType: snapshot.entityType,
+            entityFamily: snapshot.entityFamily,
+            stateSchema: metadata.schema,
+            metadata,
+            stateFullTypeName: metadata.fullTypeName,
+            idField: RepositoryIdentity.cloneFieldMetadata(metadata.idField),
+        });
+    },
+    isRepositoryOptionsObject(options) {
+        return typeof options === "object" && options !== null;
+    },
+    readEntityTypeOption(options) {
+        try {
+            return options.entityType;
+        }
+        catch {
+            throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", "Repository options entityType must be readable and resolve to a class constructor " +
+                "extending Aggregate, Projection, or ProcessManager.");
+        }
+    },
+    readRepositorySchemaOption(options, entityTypeDisplayName, entityFamily) {
+        try {
+            return options.schema;
+        }
+        catch {
+            throw new RepositoryIdentityError("ENTITY_SCHEMA_KIND_MISMATCH", `Repository entity type "${entityTypeDisplayName}" is a ${entityFamily}, but ` +
+                "the supplied state schema could not be read.");
+        }
+    },
+    isClassConstructor(entityType) {
+        if (typeof entityType !== "function") {
+            return false;
+        }
+        try {
+            const source = Function.prototype.toString.call(entityType);
+            return source.startsWith("class ");
+        }
+        catch {
+            return false;
+        }
+    },
+    /**
+     * Resolves the runtime family of a repository-owned entity constructor.
+     *
+     * @internal
+     */
+    resolveRepositoryEntityFamily(entityType) {
+        if (typeof entityType !== "function" || !RepositoryIdentity.isClassConstructor(entityType)) {
+            return undefined;
+        }
+        const runtimeEntityType = entityType;
+        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, Aggregate, Aggregate.prototype)) {
+            return "aggregate";
+        }
+        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, Projection, Projection.prototype)) {
+            return "projection";
+        }
+        if (RepositoryIdentity.hasEntityFamilyInheritance(runtimeEntityType, ProcessManager, ProcessManager.prototype)) {
+            return "process-manager";
+        }
+        return undefined;
+    },
+    hasEntityFamilyInheritance(entityType, familyConstructor, familyPrototype) {
+        try {
+            return (Object.prototype.isPrototypeOf.call(familyConstructor, entityType) &&
+                Object.prototype.isPrototypeOf.call(familyPrototype, entityType.prototype));
+        }
+        catch {
+            return false;
+        }
+    },
+    entityTypeName(entityType) {
+        if ((typeof entityType !== "object" && typeof entityType !== "function") ||
+            entityType === null) {
+            return "(anonymous)";
+        }
+        const name = RepositoryIdentity.safeStringProperty(entityType, "name");
+        return typeof name === "string" && name.length > 0 ? name : "(anonymous)";
+    },
+    safeStringProperty(value, propertyName) {
+        try {
+            const property = value[propertyName];
+            return typeof property === "string" ? property : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    describeRepositoryEntityMetadata(entityTypeDisplayName, entityFamily, schema) {
+        try {
+            return describeEntityMetadata(schema);
+        }
+        catch {
+            throw new RepositoryIdentityError("ENTITY_SCHEMA_KIND_MISMATCH", `Repository entity type "${entityTypeDisplayName}" is a ${entityFamily}, but ` +
+                "the supplied state schema does not expose supported entity metadata.");
+        }
+    },
+    cloneEntityMetadata(metadata) {
+        const idField = RepositoryIdentity.cloneFieldMetadata(metadata.idField);
+        const firstFieldRoutingHint = Object.freeze({
+            strategy: metadata.firstFieldRoutingHint.strategy,
+            field: RepositoryIdentity.cloneFieldMetadata(metadata.firstFieldRoutingHint.field),
+        });
+        return Object.freeze({
+            schema: metadata.schema,
+            descriptor: metadata.descriptor,
+            fullTypeName: metadata.fullTypeName,
+            fileDescriptor: metadata.fileDescriptor,
+            fileName: metadata.fileName,
+            kind: metadata.kind,
+            declaredVisibility: metadata.declaredVisibility,
+            visibility: metadata.visibility,
+            visibilitySource: metadata.visibilitySource,
+            idField,
+            firstFieldRoutingHint,
+            columns: Object.freeze(metadata.columns.map((field) => RepositoryIdentity.cloneFieldMetadata(field))),
+            setOnceFields: Object.freeze(metadata.setOnceFields.map((field) => RepositoryIdentity.cloneFieldMetadata(field))),
+        });
+    },
+    cloneFieldMetadata(field) {
+        return Object.freeze({
+            descriptor: field.descriptor,
+            name: field.name,
+            localName: field.localName,
+            jsonName: field.jsonName,
+            number: field.number,
+        });
+    },
+};
+Object.freeze(RepositoryIdentity);
+/**
+ * Internal entity invocation operations.
+ */
+const EntityInvocation = {
+    isEventEnvelope(signal) {
+        return (typeof signal === "object" &&
+            signal !== null &&
+            signal.$typeName === EventSchema.typeName);
+    },
+    messageTypeName(message) {
+        const typeName = message.$typeName;
+        if (typeof typeName !== "string" || typeName.length === 0) {
+            throw new Error("Repository aggregate execution requires a generated event message.");
+        }
+        return typeName;
+    },
+    invokeEntityMethod(entity, methodName, message, parameterCount = 1, context) {
+        const method = entity[methodName];
+        if (typeof method !== "function") {
+            throw new TypeError(`Repository entity execution requires method "${methodName}".`);
+        }
+        return Reflect.apply(method, entity, parameterCount === 2 ? [message, context] : [message]);
+    },
+    commandHandlerContext(command) {
+        return command.context === undefined
+            ? create(CommandContextSchema)
+            : clone(CommandContextSchema, command.context);
+    },
+    eventHandlerContext(event) {
+        return event.context === undefined
+            ? create(EventContextSchema)
+            : clone(EventContextSchema, event.context);
+    },
+    unpackRequired(message, schema, signalKind) {
+        const unpacked = AnyMessages.unpack(message, schema);
+        if (unpacked === undefined) {
+            throw new Error(`Repository ${signalKind} execution requires a readable message.`);
+        }
+        return unpacked;
+    },
+    requireSignalMessage(message, signalKind) {
+        if (message === undefined || message.typeUrl === "") {
+            throw new Error(`Repository ${signalKind} execution requires message.typeUrl.`);
+        }
+        return message;
+    },
+};
+Object.freeze(EntityInvocation);
+/**
+ * Internal repository entities operations.
+ */
+const RepositoryEntities = {
+    repositoryState(entity) {
+        return entity.state;
+    },
+    repositoryLifecycle(entity) {
+        return entity.lifecycle;
+    },
+    repositoryChanged(entity) {
+        return entity.changed === true;
+    },
+};
+Object.freeze(RepositoryEntities);
+/**
+ * Internal repository signals operations.
+ */
+const RepositorySignals = {
+    requireDeclaredRejection(handler, rejection) {
+        DeclaredRejections.require(handler.methodName, HandlerMetadataValues.thrownSchemas(handler), rejection);
+    },
+    readEventVersion(event) {
+        const number = event.context?.version?.number;
+        if (number === undefined) {
+            throw new Error("Repository aggregate execution requires readable event versions.");
+        }
+        return BigInt(number);
+    },
+    eventVersionNumber(version) {
+        if (version > 2147483647n || version < -2147483648n) {
+            throw new Error("Repository aggregate execution requires versions in the protobuf int32 range.");
+        }
+        return Number(version);
+    },
+    eventContextWithProducer(context, repository, entityId) {
+        const producerId = EntityIds.pack(repository.stateSchema, entityId);
+        return create(EventContextSchema, { ...context, producerId });
+    },
+    postRejectionEvent(runtime, repository, command, entityId, rejection) {
+        const metadata = runtime.signalMetadata.eventFromCommand(command, {});
+        const event = create(EventSchema, {
+            id: metadata.id,
+            message: AnyMessages.pack(rejection.schema, rejection.messageThrown()),
+            context: create(EventContextSchema, {
+                ...RepositorySignals.eventContextWithProducer(metadata.context, repository, entityId),
+                rejection: create(RejectionEventContextSchema, {
+                    command: clone(CommandSchema, command),
+                    stacktrace: rejection.stack ?? "",
+                }),
+            }),
+        });
+        return async () => {
+            try {
+                // spine-log-boundary: server.repository_rejection_follow_up
+                await runtime.publisher.publishRejectionEvent(event);
+            }
+            catch (error) {
+                runtime.publisher.reportFailure("event", event, error);
+            }
+        };
+    },
+    requireCommandId(command) {
+        if (command.id === undefined || command.id.uuid.trim().length === 0) {
+            throw new Error("Repository aggregate execution requires command.id to bind event origins.");
+        }
+        return command.id;
+    },
+    requireEventId(event) {
+        if (event.id === undefined || event.id.value.trim().length === 0) {
+            throw new Error("Repository projection inbox handoff requires event.id.");
+        }
+        return event.id;
+    },
+    executionTimestamp() {
+        const milliseconds = Date.now();
+        return create(TimestampSchema, {
+            seconds: BigInt(Math.floor(milliseconds / 1_000)),
+            nanos: (milliseconds % 1_000) * 1_000_000,
+        });
+    },
+};
+/**
+ * Builds and best-effort dispatches committed entity state notifications.
+ */
+class EntityStateChangePublishing {
+    command(runtime, repository, command, entityId, oldState, oldLifecycle, newState, lifecycle, version) {
+        this.#publish(runtime, () => runtime.signalMetadata.eventFromCommand(command, {
+            version,
+        }), {
+            id: AnyMessages.pack(CommandIdSchema, command.id),
+            typeUrl: command.message?.typeUrl ?? "",
+        }, { repository, entityId, oldState, oldLifecycle, newState, lifecycle, version });
+    }
+    event(runtime, repository, source, entityId, oldState, oldLifecycle, newState, lifecycle, version) {
+        this.#publish(runtime, () => runtime.signalMetadata.eventFromEvent(source, {
+            version,
+        }), {
+            id: AnyMessages.pack(EventIdSchema, source.id),
+            typeUrl: source.message?.typeUrl ?? "",
+        }, { repository, entityId, oldState, oldLifecycle, newState, lifecycle, version });
+    }
+    #publish(runtime, metadataFor, origin, change) {
+        const drafts = this.#drafts(origin, change);
+        drafts.forEach((draft) => {
+            const metadata = metadataFor();
+            runtime.registerSystemEventSchema(draft.schema);
+            const event = create(EventSchema, {
+                id: metadata.id,
+                message: AnyMessages.pack(draft.schema, draft.messageAt(metadata.context.timestamp)),
+                context: RepositorySignals.eventContextWithProducer(metadata.context, change.repository, change.entityId),
+            });
+            this.#post(runtime, event);
+        });
+    }
+    #drafts(origin, change) {
+        const fields = this.#fields(origin, change);
+        const archive = this.#archiveDraft(fields, change);
+        const deletion = this.#deleteDraft(fields, change);
+        return [...this.#stateDrafts(fields, change), archive, deletion].filter((draft) => draft !== undefined);
+    }
+    #fields(origin, change) {
+        const entity = create(MessageIdSchema, {
+            id: this.#packEntityId(change.repository, change.entityId),
+            typeUrl: TypeUrls.derive(change.repository.stateSchema),
+        });
+        return {
+            entity,
+            signalId: [create(MessageIdSchema, { id: origin.id, typeUrl: origin.typeUrl })],
+            state: AnyMessages.pack(change.repository.stateSchema, change.newState),
+            version: create(VersionSchema, { number: change.version }),
+        };
+    }
+    #stateDrafts(fields, change) {
+        const drafts = [];
+        if (change.oldState === undefined) {
+            drafts.push({
+                schema: EntityLog.EntityCreatedSchema,
+                messageAt: () => create(EntityLog.EntityCreatedSchema, {
+                    entity: fields.entity,
+                    kind: this.#kind(change.repository.metadata.kind),
+                }),
+            });
+        }
+        if (change.oldState === undefined ||
+            !this.#sameState(change.repository.stateSchema, change.oldState, change.newState)) {
+            drafts.push(this.#stateChangedDraft(fields, change));
+        }
+        return drafts;
+    }
+    #stateChangedDraft(fields, change) {
+        return {
+            schema: EntityLog.EntityStateChangedSchema,
+            messageAt: (when) => create(EntityLog.EntityStateChangedSchema, {
+                entity: fields.entity,
+                ...(change.oldState === undefined
+                    ? {}
+                    : {
+                        oldState: AnyMessages.pack(change.repository.stateSchema, change.oldState),
+                    }),
+                newState: fields.state,
+                signalId: fields.signalId,
+                when,
+                newVersion: fields.version,
+            }),
+        };
+    }
+    #archiveDraft(fields, change) {
+        const previous = change.oldLifecycle ?? { archived: false, deleted: false };
+        if (previous.archived === change.lifecycle.archived)
+            return undefined;
+        return change.lifecycle.archived
+            ? {
+                schema: EntityLog.EntityArchivedSchema,
+                messageAt: (when) => create(EntityLog.EntityArchivedSchema, {
+                    entity: fields.entity,
+                    signalId: fields.signalId,
+                    when,
+                    version: fields.version,
+                    lastState: fields.state,
+                }),
+            }
+            : {
+                schema: EntityLog.EntityUnarchivedSchema,
+                messageAt: (when) => create(EntityLog.EntityUnarchivedSchema, {
+                    entity: fields.entity,
+                    signalId: fields.signalId,
+                    when,
+                    version: fields.version,
+                    state: fields.state,
+                }),
+            };
+    }
+    #deleteDraft(fields, change) {
+        const previous = change.oldLifecycle ?? { archived: false, deleted: false };
+        if (previous.deleted === change.lifecycle.deleted)
+            return undefined;
+        return change.lifecycle.deleted
+            ? {
+                schema: EntityLog.EntityDeletedSchema,
+                messageAt: (when) => create(EntityLog.EntityDeletedSchema, {
+                    entity: fields.entity,
+                    signalId: fields.signalId,
+                    when,
+                    version: fields.version,
+                    deletion: { case: "markedAsDeleted", value: true },
+                    lastState: fields.state,
+                }),
+            }
+            : {
+                schema: EntityLog.EntityRestoredSchema,
+                messageAt: (when) => create(EntityLog.EntityRestoredSchema, {
+                    entity: fields.entity,
+                    signalId: fields.signalId,
+                    when,
+                    version: fields.version,
+                    state: fields.state,
+                }),
+            };
+    }
+    #post(runtime, event) {
+        try {
+            // spine-log-boundary: server.repository_system_follow_up
+            void runtime.publisher.publishSystemEvent(event);
+        }
+        catch (error) {
+            runtime.publisher.reportFailure("system-event", event, error);
+        }
+    }
+    #sameState(schema, left, right) {
+        const leftBytes = toBinary(schema, left);
+        const rightBytes = toBinary(schema, right);
+        return (leftBytes.length === rightBytes.length &&
+            leftBytes.every((value, index) => value === rightBytes[index]));
+    }
+    #kind(kind) {
+        return kind === "aggregate"
+            ? EntityOption_Kind.AGGREGATE
+            : kind === "projection"
+                ? EntityOption_Kind.PROJECTION
+                : EntityOption_Kind.PROCESS_MANAGER;
+    }
+    #packEntityId(repository, entityId) {
+        return EntityIds.pack(repository.stateSchema, entityId);
+    }
+}
+const EntityStateChangePublisher = Object.freeze(new EntityStateChangePublishing());
+/**
+ * Builds and best-effort dispatches accepted handler diagnostics.
+ */
+class HandlerDispatchPublishing {
+    command(runtime, repository, command, entityId) {
+        try {
+            const context = runtime.signalMetadata.eventContext({
+                origin: runtime.signalMetadata.originFromCommand(command),
+            });
+            const event = create(EventSchema, {
+                id: runtime.signalMetadata.eventId(),
+                message: AnyMessages.pack(EntityLog.CommandDispatchedToHandlerSchema, this.#message(repository, command, entityId, context.timestamp)),
+                context,
+            });
+            this.#post(runtime, EntityLog.CommandDispatchedToHandlerSchema, event);
+        }
+        catch (error) {
+            runtime.publisher.reportFailure("event", create(EventSchema), error);
+        }
+    }
+    subscriber(runtime, repository, event, entityId) {
+        this.#publishEvent(runtime, repository, event, entityId, EntityLog.EventDispatchedToSubscriberSchema);
+    }
+    reactor(runtime, repository, event, entityId) {
+        this.#publishEvent(runtime, repository, event, entityId, EntityLog.EventDispatchedToReactorSchema);
+    }
+    #publishEvent(runtime, repository, event, entityId, schema) {
+        try {
+            const context = runtime.signalMetadata.eventContext({
+                origin: runtime.signalMetadata.originFromEvent(event),
+            });
+            const diagnostic = create(EventSchema, {
+                id: runtime.signalMetadata.eventId(),
+                message: AnyMessages.pack(schema, this.#eventMessage(schema, repository, event, entityId, context.timestamp)),
+                context,
+            });
+            this.#post(runtime, schema, diagnostic);
+        }
+        catch (error) {
+            runtime.publisher.reportFailure("event", create(EventSchema), error);
+        }
+    }
+    #message(repository, command, entityId, whenDispatched) {
+        return create(EntityLog.CommandDispatchedToHandlerSchema, {
+            receiver: create(MessageIdSchema, {
+                id: this.#packEntityId(repository, entityId),
+                typeUrl: TypeUrls.derive(repository.stateSchema),
+            }),
+            payload: clone(CommandSchema, command),
+            whenDispatched,
+            entityType: create(EntityTypeNameSchema, {
+                impl: { case: "javaClassName", value: repository.entityType.name },
+            }),
+        });
+    }
+    #post(runtime, schema, event) {
+        try {
+            runtime.registerSystemEventSchema(schema);
+            // spine-log-boundary: server.repository_system_dispatch_follow_up
+            void runtime.publisher.publishSystemEvent(event);
+        }
+        catch (error) {
+            runtime.publisher.reportFailure("system-event", event, error);
+        }
+    }
+    #packEntityId(repository, entityId) {
+        return EntityIds.pack(repository.stateSchema, entityId);
+    }
+    #eventMessage(schema, repository, event, entityId, whenDispatched) {
+        const fields = {
+            receiver: create(MessageIdSchema, {
+                id: this.#packEntityId(repository, entityId),
+                typeUrl: TypeUrls.derive(repository.stateSchema),
+            }),
+            payload: clone(EventSchema, event),
+            whenDispatched,
+            entityType: create(EntityTypeNameSchema, {
+                impl: { case: "javaClassName", value: repository.entityType.name },
+            }),
+        };
+        return schema === EntityLog.EventDispatchedToSubscriberSchema
+            ? create(EntityLog.EventDispatchedToSubscriberSchema, fields)
+            : create(EntityLog.EventDispatchedToReactorSchema, fields);
+    }
+}
+const HandlerDispatchPublisher = Object.freeze(new HandlerDispatchPublishing());
+Object.freeze(RepositorySignals);
+/**
+ * Internal repository stand operations.
+ */
+const RepositoryStand = {
+    standUpdateOptions(tenantId, version, lifecycle) {
+        return Object.freeze({
+            ...(tenantId === undefined ? {} : { tenantId }),
+            ...(version === undefined ? {} : { version }),
+            lifecycle,
+        });
+    },
+    projectionVersion(version) {
+        return typeof version === "bigint" ? Number(version) : (version?.number ?? 0);
+    },
+    processManagerVersion(entity) {
+        const version = entity.version;
+        return typeof version === "number" ? version + 1 : 1;
+    },
+    processManagerProducedVersion(sequence) {
+        return sequence;
+    },
+};
+Object.freeze(RepositoryStand);
+/**
+ * Internal repository tenants operations.
+ */
+const RepositoryTenants = {
+    entityInboxDeliveryContext(context, tenantId) {
+        if (!context.multitenant) {
+            return Object.freeze({ name: context.name, multitenant: false });
+        }
+        const tid = tenantId;
+        if (tid === undefined) {
+            throw new Error(`Multitenant Entity Inbox handoff for "${context.name}" requires tenantId.`);
+        }
+        return Object.freeze({
+            name: context.name,
+            multitenant: true,
+            tenantId: RepositoryTenants.require(tid),
+        });
+    },
+    projectionDeliveryContext(context, tenantId) {
+        if (!context.multitenant) {
+            return Object.freeze({ name: context.name, multitenant: false });
+        }
+        const tid = tenantId;
+        if (tid === undefined) {
+            throw new Error(`Multitenant projection inbox handoff for "${context.name}" requires tenantId.`);
+        }
+        return Object.freeze({
+            name: context.name,
+            multitenant: true,
+            tenantId: RepositoryTenants.require(tid),
+        });
+    },
+    requireProjectionTenant(context, event) {
+        if (!context.multitenant) {
+            return undefined;
+        }
+        const tenantId = RepositoryTenants.readEventTenant(event);
+        if (tenantId === undefined) {
+            throw new Error(`Multitenant projection inbox handoff for "${context.name}" requires tenantId.`);
+        }
+        return RepositoryTenants.require(tenantId);
+    },
+    requirePmEventTenant(context, event) {
+        if (!context.multitenant) {
+            return undefined;
+        }
+        const tenantId = RepositoryTenants.readEventTenant(event);
+        if (tenantId === undefined) {
+            throw new Error(`Multitenant Entity Inbox handoff for "${context.name}" requires tenantId.`);
+        }
+        return RepositoryTenants.require(tenantId);
+    },
+    requireCommandTenant(context, command) {
+        if (!context.multitenant) {
+            return undefined;
+        }
+        const tenantId = RepositoryTenants.readCommandTenant(command);
+        if (tenantId === undefined) {
+            throw new Error(`Multitenant Entity Inbox handoff for "${context.name}" requires tenantId.`);
+        }
+        return RepositoryTenants.require(tenantId);
+    },
+    storageContextForCommand(context, command) {
+        if (!context.multitenant) {
+            return Object.freeze({ name: context.name, multitenant: false });
+        }
+        const tenantId = RepositoryTenants.readCommandTenant(command);
+        if (tenantId === undefined)
+            throw new Error(`Multitenant command for "${context.name}" requires tenantId.`);
+        return Object.freeze({
+            name: context.name,
+            multitenant: true,
+            tenantId: RepositoryTenants.require(tenantId),
+        });
+    },
+    storageContextForEvent(context, event) {
+        if (!context.multitenant) {
+            return Object.freeze({ name: context.name, multitenant: false });
+        }
+        const tenantId = RepositoryTenants.readEventTenant(event);
+        if (tenantId === undefined)
+            throw new Error(`Multitenant event for "${context.name}" requires tenantId.`);
+        return Object.freeze({
+            name: context.name,
+            multitenant: true,
+            tenantId: RepositoryTenants.require(tenantId),
+        });
+    },
+    storageContextForTenant(context, tenantId) {
+        if (!context.multitenant)
+            return Object.freeze({ name: context.name, multitenant: false });
+        if (tenantId === undefined)
+            throw new Error(`Multitenant storage for "${context.name}" requires tenantId.`);
+        return Object.freeze({
+            name: context.name,
+            multitenant: true,
+            tenantId: RepositoryTenants.require(tenantId),
+        });
+    },
+    readCommandTenant(command) {
+        return RepositoryTenants.tenantValue(command.context?.actorContext?.tenantId);
+    },
+    standTenantOptions(context, event) {
+        if (!context.multitenant) {
+            return {};
+        }
+        const tenantId = RepositoryTenants.readEventTenant(event);
+        return tenantId === undefined ? {} : { tenantId };
+    },
+    commandStandOptions(context, command) {
+        if (!context.multitenant) {
+            return {};
+        }
+        const tenantId = RepositoryTenants.readCommandTenant(command);
+        return tenantId === undefined ? {} : { tenantId };
+    },
+    readEventTenant(event) {
+        switch (event.context?.origin.case) {
+            case "importContext":
+                return RepositoryTenants.tenantValue(event.context.origin.value.tenantId);
+            case "pastMessage":
+                return RepositoryTenants.tenantValue(event.context.origin.value.actorContext?.tenantId);
+            default:
+                return undefined;
+        }
+    },
+    tenantValue(tenantId) {
+        return tenantId === undefined ? undefined : clone(TenantIdSchema, tenantId);
+    },
+    require(tenantId) {
+        return TenantBoundary.from(tenantId).tenantId;
+    },
+    equal(left, right) {
+        return TenantBoundary.from(left).key === TenantBoundary.from(right).key;
+    },
+};
+Object.freeze(RepositoryTenants);
+/**
+ * Internal repository handlers operations.
+ */
+const RepositoryHandlers = {
+    normalizeHandlers(handlersOption) {
+        if (handlersOption === undefined) {
+            return Object.freeze([]);
+        }
+        if (RepositoryHandlers.isHandlersArray(handlersOption)) {
+            return Object.freeze([...handlersOption]);
+        }
+        return Object.freeze([handlersOption]);
+    },
+    createCommandReactionMap(handlers) {
+        const byEvent = new Map();
+        const registry = new HandlerMetadataRegistry(handlers);
+        for (const entry of registry.findHandlersByKind("command-reaction")) {
+            if (RepositoryHandlers.handlerEmittedSchemas(entry.handler).length === 0) {
+                continue;
+            }
+            RepositoryHandlers.pushMapValue(byEvent, entry.handler.messageFullTypeName, entry);
+        }
+        return byEvent;
+    },
+    createEventFilterPlans(byEvent, stringifiers) {
+        const plans = new Map();
+        for (const [eventType, values] of byEvent) {
+            plans.set(eventType, EventHandlerFilters.compile(values.map((value) => ({
+                value,
+                schema: value.handler.schema,
+                ...(value.handler.where === undefined ? {} : { where: value.handler.where }),
+            })), stringifiers));
+        }
+        return plans;
+    },
+    forOrigin(values, external) {
+        return Object.freeze(values.filter((value) => (value.handler.origin === "external") === external));
+    },
+    readinessMap(schemas, find) {
+        return new Map(schemas.map((schema) => [schema.typeName, find(schema.typeName)]));
+    },
+    handlerEmittedSchemas(handler) {
+        return HandlerMetadataValues.returnedSchemas(handler);
+    },
+    handlerThrownSchemas(handler) {
+        return HandlerMetadataValues.thrownSchemas(handler);
+    },
+    isHandlersArray(value) {
+        return Array.isArray(value);
+    },
+    validateHandlers(entityType, metadata, handlers) {
+        for (const handlersMetadata of handlers) {
+            if (!HandlerMetadataValues.isAuthentic(handlersMetadata) ||
+                handlersMetadata.entityType !== entityType ||
+                handlersMetadata.entity.fullTypeName !== metadata.fullTypeName) {
+                throw new RepositoryIdentityError("ENTITY_SCHEMA_KIND_MISMATCH", `Repository entity type "${entityType.name}" does not match the supplied handler metadata.`);
+            }
+            if (metadata.kind !== "process-manager" &&
+                (handlersMetadata.commandSubstitutions.length > 0 ||
+                    handlersMetadata.commandReactions.length > 0)) {
+                throw new RepositoryIdentityError("UNSUPPORTED_ENTITY_TYPE", "Only Process Manager repositories support @Command handlers.");
+            }
+        }
+    },
+    uniqueSchemas(schemas) {
+        const byTypeUrl = new Map();
+        for (const schema of schemas) {
+            byTypeUrl.set(TypeUrls.derive(schema), schema);
+        }
+        return Object.freeze([...byTypeUrl.values()]);
+    },
+    pushMapValue(map, key, value) {
+        const values = map.get(key);
+        if (values === undefined) {
+            map.set(key, [value]);
+            return;
+        }
+        values.push(value);
+    },
+};
+Object.freeze(RepositoryHandlers);
+/**
+ * Internal repository routes operations.
+ */
+const RepositoryRoutes = {
+    createRepositoryRouting(entityType, entityFamily, metadata, handlersOption, producedEvents, commandRouting, eventRouting, stateUpdateRouting, stringifiers) {
+        return RepositoryRoutes.prepareRouting({
+            entityType,
+            entityFamily,
+            metadata,
+            handlersOption,
+            producedEvents,
+            commandRouting,
+            eventRouting,
+            stateUpdateRouting,
+            stringifiers,
+        });
+    },
+    prepareRouting(input) {
+        const handlers = RepositoryHandlers.normalizeHandlers(input.handlersOption);
+        RepositoryHandlers.validateHandlers(input.entityType, input.metadata, handlers);
+        const readiness = RepositoryRoutes.readiness(handlers);
+        const schemas = RepositoryRoutes.routingSchemas(handlers, input.producedEvents);
+        RepositoryRoutes.validateStateSchemas(input.entityFamily, input.metadata, schemas.state);
+        const stateSubscriptions = RepositoryRoutes.stateSubscriptions(handlers);
+        const filters = RepositoryRoutes.routingFilters(handlers, schemas.event, readiness.event, input.stringifiers);
+        const routes = RepositoryRoutes.routingMaps(schemas, input.commandRouting, input.eventRouting, input.stateUpdateRouting, input.metadata.idField);
+        return RepositoryRoutes.freezeRouting(schemas, readiness, stateSubscriptions, filters, routes, input.metadata.idField);
+    },
+    readiness(handlers) {
+        return handlers.length === 0
+            ? { command: undefined, event: undefined }
+            : {
+                command: CommandRegistrationReadiness.fromEntityHandlers(handlers),
+                event: EventRegistrationReadiness.fromEntityHandlers(handlers),
+            };
+    },
+    routingSchemas(handlers, producedEvents) {
+        const accepted = RepositoryRoutes.acceptedSchemas(handlers);
+        const origins = RepositoryRoutes.originSchemas(handlers);
+        const produced = RepositoryRoutes.producedSchemas(handlers, producedEvents);
+        return { ...accepted, ...origins, ...produced };
+    },
+    acceptedSchemas(handlers) {
+        const command = RepositoryHandlers.uniqueSchemas(handlers.flatMap((handler) => [
+            ...handler.commandAssignments.map((assignment) => assignment.schema),
+            ...handler.commandSubstitutions.map((substitution) => substitution.schema),
+        ]));
+        const event = RepositoryHandlers.uniqueSchemas(handlers.flatMap((handler) => [
+            ...handler.commandReactions.map((reaction) => reaction.schema),
+            ...handler.eventSubscriptions.map((subscription) => subscription.schema),
+            ...handler.eventReactions.map((reaction) => reaction.schema),
+            ...handler.eventApplications.map((application) => application.schema),
+        ]));
+        const state = RepositoryHandlers.uniqueSchemas(handlers.flatMap((handler) => handler.stateSubscriptions.map((subscription) => subscription.schema)));
+        return { command, event, state };
+    },
+    originSchemas(handlers) {
+        const schemas = (origin) => RepositoryHandlers.uniqueSchemas(handlers.flatMap((handler) => handler.handlers
+            .filter((candidate) => candidate.origin === origin &&
+            (candidate.kind === "event-subscription" ||
+                candidate.kind === "event-reaction" ||
+                candidate.kind === "command-reaction"))
+            .map((candidate) => candidate.schema)));
+        return { domesticEvent: schemas("domestic"), externalEvent: schemas("external") };
+    },
+    producedSchemas(handlers, explicitEvents) {
+        const producedEvent = RepositoryHandlers.uniqueSchemas([
+            ...explicitEvents,
+            ...handlers.flatMap((handler) => [
+                ...handler.commandAssignments.flatMap((value) => RepositoryHandlers.handlerEmittedSchemas(value)),
+                ...handler.commandAssignments.flatMap((value) => RepositoryHandlers.handlerThrownSchemas(value)),
+                ...handler.commandSubstitutions.flatMap((value) => RepositoryHandlers.handlerThrownSchemas(value)),
+                ...handler.eventReactions.flatMap((value) => RepositoryHandlers.handlerEmittedSchemas(value)),
+            ]),
+        ]);
+        const producedCommand = RepositoryHandlers.uniqueSchemas(handlers.flatMap((handler) => [
+            ...handler.commandSubstitutions.flatMap((value) => RepositoryHandlers.handlerEmittedSchemas(value)),
+            ...handler.commandReactions.flatMap((value) => RepositoryHandlers.handlerEmittedSchemas(value)),
+        ]));
+        return { producedEvent, producedCommand };
+    },
+    validateStateSchemas(entityFamily, metadata, schemas) {
+        if (entityFamily !== "projection" && schemas.length > 0) {
+            throw new Error("Entity state subscriptions are supported only by Projection repositories.");
+        }
+        if (schemas.some((schema) => schema.typeName === metadata.schema.typeName)) {
+            throw new Error("A Projection cannot subscribe to updates of its repository state because each " +
+                "resulting update would be routed back to the same repository.");
+        }
+    },
+    routingFilters(handlers, eventSchemas, readiness, stringifiers) {
+        const commandReactionMap = RepositoryHandlers.createCommandReactionMap(handlers);
+        const subscribers = RepositoryHandlers.readinessMap(eventSchemas, (typeName) => readiness?.findEventSubscribers(typeName) ?? []);
+        const reactors = RepositoryHandlers.readinessMap(eventSchemas, (typeName) => readiness?.findEventReactors(typeName) ?? []);
+        return {
+            commandReactionMap,
+            commandReactions: RepositoryHandlers.createEventFilterPlans(commandReactionMap, stringifiers),
+            eventSubscribers: RepositoryHandlers.createEventFilterPlans(subscribers, stringifiers),
+            eventReactors: RepositoryHandlers.createEventFilterPlans(reactors, stringifiers),
+        };
+    },
+    routingMaps(schemas, command, event, state, idField) {
+        return {
+            command: RepositoryRoutes.resolveCommandRoutes(schemas.command, command),
+            event: RepositoryRoutes.resolveEventRoutes(schemas.event, event),
+            state: RepositoryRoutes.resolveStateRoutes(schemas.state, state, idField),
+        };
+    },
+    freezeRouting(schemas, readiness, stateSubscriptions, filters, routes, idField) {
+        return Object.freeze({
+            commandSchemas: schemas.command,
+            eventSchemas: schemas.event,
+            domesticEventSchemas: schemas.domesticEvent,
+            externalEventSchemas: schemas.externalEvent,
+            producedEventSchemas: schemas.producedEvent,
+            producedCommandSchemas: schemas.producedCommand,
+            commandReadiness: readiness.command,
+            eventReadiness: readiness.event,
+            stateSchemas: schemas.state,
+            stateSubscriptions,
+            ...RepositoryRoutes.handlerSelectors(filters),
+            ...RepositoryRoutes.routeSelectors(schemas, readiness, stateSubscriptions, filters, routes, idField),
+        });
+    },
+    handlerSelectors(filters) {
+        return {
+            commandReactions: (typeName, message, external) => RepositoryRoutes.selectHandlers(filters.commandReactions, typeName, message, external),
+            eventReactors: (typeName, message, external) => RepositoryRoutes.selectHandlers(filters.eventReactors, typeName, message, external),
+            eventSubscribers: (typeName, message, external) => RepositoryRoutes.selectHandlers(filters.eventSubscribers, typeName, message, external),
+        };
+    },
+    selectHandlers(filters, typeName, message, external) {
+        return RepositoryHandlers.forOrigin(filters.get(typeName)?.select(message) ?? Object.freeze([]), external);
+    },
+    routeSelectors(schemas, readiness, stateSubscriptions, filters, routes, idField) {
+        return {
+            routeCommand: RepositoryRoutes.commandSelector(schemas, readiness, routes, idField),
+            routeEvent: RepositoryRoutes.eventSelector(schemas, readiness, filters, routes, idField),
+            routeStateUpdate: RepositoryRoutes.stateSelector(schemas, stateSubscriptions, routes, idField),
+        };
+    },
+    commandSelector(schemas, readiness, routes, idField) {
+        return (command) => RepositoryRoutes.routeCommand(command, readiness.command, schemas.command, idField, routes.command);
+    },
+    eventSelector(schemas, readiness, filters, routes, idField) {
+        return (event) => RepositoryRoutes.routeEvent(event, readiness.event, filters.commandReactionMap, schemas.event, idField, routes.event);
+    },
+    stateSelector(schemas, subscriptions, routes, idField) {
+        return (event) => RepositoryRoutes.routeStateUpdate(event, schemas.state, subscriptions, idField, routes.state);
+    },
+    routeCommand(command, readiness, schemas, targetIdField, commandRoutes) {
+        const message = command.message;
+        if (message === undefined || message.typeUrl === "") {
+            throw new Error("Repository command routing requires command.message.typeUrl.");
+        }
+        const schema = RepositoryRoutes.schemaForTypeUrl(schemas, message.typeUrl, "command");
+        const assignee = readiness?.findCommandAssignee(schema.typeName);
+        if (assignee === undefined) {
+            throw new Error(`Repository command routing has no assignee for "${schema.typeName}".`);
+        }
+        const customRoute = commandRoutes.get(schema);
+        const candidateId = customRoute === undefined
+            ? RepositoryRoutes.readFirstFieldId(message, schema, "command")
+            : RepositoryRoutes.callCommandRoute(customRoute, message, schema, command.context);
+        return Object.freeze({
+            entityId: RepositoryRoutes.readRouteId(candidateId, targetIdField, "command"),
+            messageFullTypeName: schema.typeName,
+            invocation: "deferred",
+        });
+    },
+    resolveCommandRoutes(schemas, routing) {
+        const routes = new Map();
+        RoutingDeclarations.validate(routing, schemas, "command");
+        for (const schema of schemas) {
+            const route = RoutingDeclarations.select(routing, schema);
+            if (route !== undefined)
+                routes.set(schema, route);
+        }
+        return routes;
+    },
+    callCommandRoute(route, message, schema, context) {
+        const unpacked = AnyMessages.unpack(message, schema);
+        if (unpacked === undefined) {
+            throw new Error("Repository command routing requires a readable Command message.");
+        }
+        return route(unpacked, context ?? create(CommandContextSchema));
+    },
+    routeEvent(event, readiness, commandReactions, schemas, targetIdField, eventRoutes) {
+        const message = event.message;
+        if (message === undefined || message.typeUrl === "") {
+            throw new Error("Repository event routing requires event.message.typeUrl.");
+        }
+        const schema = RepositoryRoutes.schemaForTypeUrl(schemas, message.typeUrl, "event");
+        const hasReceiver = (commandReactions.get(schema.typeName)?.length ?? 0) > 0 ||
+            (readiness?.findEventSubscribers(schema.typeName).length ?? 0) > 0 ||
+            (readiness?.findEventReactors(schema.typeName).length ?? 0) > 0 ||
+            (readiness?.findEventApplications(schema.typeName).length ?? 0) > 0;
+        if (!hasReceiver) {
+            throw new Error(`Repository event routing has no receiver for "${schema.typeName}".`);
+        }
+        const customRoute = eventRoutes.get(schema);
+        if (customRoute !== undefined) {
+            return Object.freeze({
+                entityIds: RepositoryRoutes.callEventRoute(customRoute, message, schema, event.context, targetIdField),
+                messageFullTypeName: schema.typeName,
+                invocation: "deferred",
+            });
+        }
+        const targetId = RepositoryRoutes.readEventEntityId(event, message, schema, targetIdField);
+        return Object.freeze({
+            entityIds: Object.freeze([targetId]),
+            messageFullTypeName: schema.typeName,
+            invocation: "deferred",
+        });
+    },
+    resolveEventRoutes(schemas, routing) {
+        const routes = new Map();
+        RoutingDeclarations.validate(routing, schemas, "event");
+        for (const schema of schemas) {
+            const route = RoutingDeclarations.select(routing, schema);
+            if (route !== undefined)
+                routes.set(schema, route);
+        }
+        return routes;
+    },
+    stateSubscriptions(handlers) {
+        const byType = new Map();
+        for (const entityHandlers of handlers) {
+            for (const handler of entityHandlers.stateSubscriptions) {
+                RepositoryHandlers.pushMapValue(byType, handler.messageFullTypeName, Object.freeze({
+                    entityHandlers,
+                    entityType: entityHandlers.entityType,
+                    entity: entityHandlers.entity,
+                    handler,
+                }));
+            }
+        }
+        return new Map([...byType].map(([typeName, subscriptions]) => [typeName, Object.freeze([...subscriptions])]));
+    },
+    resolveStateRoutes(schemas, routing, targetIdField) {
+        const routes = new Map();
+        RoutingDeclarations.validate(routing, schemas, "state-update");
+        for (const schema of schemas) {
+            const route = RoutingDeclarations.select(routing, schema);
+            if (route !== undefined)
+                routes.set(schema, route);
+            else if (!schema.fields.some((field) => RepositoryRoutes.compatibleStateIdField(field, targetIdField))) {
+                throw new Error(`Repository state-update routing has no compatible field in "${schema.typeName}".`);
+            }
+        }
+        return routes;
+    },
+    routeStateUpdate(event, schemas, subscriptions, targetIdField, routes) {
+        const update = RepositoryRoutes.decodeStateUpdate(event, schemas, "Repository state-update routing");
+        const candidates = subscriptions.get(update?.schema.typeName ?? "") ?? [];
+        const interested = Object.freeze(candidates.filter((subscriber) => (subscriber.handler.origin === "external") === (event.context?.external === true)));
+        if (update === undefined || interested.length === 0) {
+            return undefined;
+        }
+        const { schema, state } = update;
+        const custom = routes.get(schema);
+        const candidateIds = custom === undefined
+            ? [RepositoryRoutes.firstCompatibleId(state, schema, targetIdField, "state update")]
+            : RepositoryRoutes.callStateUpdateRoute(custom, state, event.context, targetIdField);
+        return Object.freeze({
+            entityIds: Object.freeze([...candidateIds]),
+            messageFullTypeName: schema.typeName,
+            state,
+            subscribers: interested,
+            invocation: "deferred",
+        });
+    },
+    decodeStateUpdate(event, schemas, operation) {
+        const message = event.message;
+        if (message?.typeUrl !== TypeUrls.derive(EntityLog.EntityStateChangedSchema)) {
+            throw new Error(`${operation} requires an EntityStateChanged System event.`);
+        }
+        const changed = AnyMessages.unpack(message, EntityLog.EntityStateChangedSchema);
+        const packedState = changed?.newState;
+        if (packedState === undefined || packedState.typeUrl === "") {
+            throw new Error(`${operation} requires EntityStateChanged.newState.`);
+        }
+        const schema = schemas.find((candidate) => TypeUrls.derive(candidate) === packedState.typeUrl);
+        if (schema === undefined)
+            return undefined;
+        const state = AnyMessages.unpack(packedState, schema);
+        if (state === undefined)
+            throw new Error(`${operation} requires a readable Entity state.`);
+        return Object.freeze({ schema, state });
+    },
+    callStateUpdateRoute(route, state, context, targetIdField) {
+        const candidates = route(state, context ?? create(EventContextSchema));
+        if (!Array.isArray(candidates))
+            throw new Error("Repository state-update routing requires an array of Entity IDs.");
+        if (candidates.length > 1_000)
+            throw new Error("Repository state-update routing accepts at most 1,000 Entity IDs.");
+        const unique = new Map();
+        for (const candidate of candidates) {
+            const id = RepositoryRoutes.readRouteId(candidate, targetIdField, "state update");
+            const key = InboxTargets.key(InboxMessages.inboxTargetId(id, targetIdField));
+            if (!unique.has(key))
+                unique.set(key, structuredClone(id));
+        }
+        return Object.freeze([...unique.values()]);
+    },
+    callEventRoute(route, message, schema, context, targetIdField) {
+        const unpacked = AnyMessages.unpack(message, schema);
+        if (unpacked === undefined) {
+            throw new Error("Repository event routing requires a readable Event message.");
+        }
+        const candidates = route(unpacked, context ?? create(EventContextSchema));
+        if (!Array.isArray(candidates)) {
+            throw new Error("Repository event routing requires an array of Entity IDs.");
+        }
+        if (candidates.length > 1_000) {
+            throw new Error("Repository event routing accepts at most 1,000 Entity IDs.");
+        }
+        const unique = new Map();
+        for (const candidate of candidates) {
+            const id = RepositoryRoutes.readRouteId(candidate, targetIdField, "event");
+            const key = InboxTargets.key(InboxMessages.inboxTargetId(id, targetIdField));
+            if (!unique.has(key))
+                unique.set(key, structuredClone(id));
+        }
+        return Object.freeze([...unique.values()]);
+    },
+    schemaForTypeUrl(schemas, typeUrl, signalKind) {
+        const schema = schemas.find((candidate) => TypeUrls.derive(candidate) === typeUrl);
+        if (schema === undefined) {
+            throw new Error(`Repository ${signalKind} routing has no schema for "${typeUrl}".`);
+        }
+        return schema;
+    },
+    readFirstFieldId(message, schema, signalKind) {
+        const unpacked = AnyMessages.unpack(message, schema);
+        const firstField = schema.fields[0];
+        if (unpacked === undefined || firstField === undefined) {
+            throw new Error(`Repository ${signalKind} routing requires a readable first field.`);
+        }
+        if (firstField.fieldKind === "list" || firstField.fieldKind === "map") {
+            throw new Error(`Repository ${signalKind} routing requires a singular non-map first field.`);
+        }
+        const value = unpacked[firstField.localName];
+        if (value === undefined || value === null || RepositoryRoutes.isBlankRouteId(value)) {
+            throw new Error(`Repository ${signalKind} routing requires a non-empty first field.`);
+        }
+        if (signalKind === "command" && (value === 0 || value === false)) {
+            throw new Error("Repository command routing requires a non-default first field.");
+        }
+        return value;
+    },
+    firstCompatibleId(state, schema, targetIdField, signalKind) {
+        const field = schema.fields.find((candidate) => RepositoryRoutes.compatibleStateIdField(candidate, targetIdField));
+        if (field === undefined)
+            throw new Error("Repository state-update routing requires a compatible state field.");
+        const value = state[field.localName];
+        return RepositoryRoutes.readRouteId(value, targetIdField, signalKind);
+    },
+    compatibleStateIdField(field, targetIdField) {
+        if (field.fieldKind === "list" || field.fieldKind === "map")
+            return false;
+        const target = targetIdField.descriptor;
+        if (field.fieldKind === "message" && target.fieldKind === "message")
+            return field.message.typeName === target.message.typeName;
+        if (field.fieldKind !== "scalar" || target.fieldKind !== "scalar")
+            return false;
+        try {
+            return (RepositoryRoutes.primitiveIdentifierType(field.scalar) ===
+                RepositoryRoutes.primitiveIdentifierType(target.scalar));
+        }
+        catch {
+            return false;
+        }
+    },
+    isBlankRouteId(value) {
+        const id = PrimitiveIds.readFinite(value);
+        return typeof id === "string" && id.trim().length === 0;
+    },
+    readEventEntityId(event, message, schema, targetIdField) {
+        const producerId = event.context?.producerId;
+        if (producerId === undefined || producerId.typeUrl.trim().length === 0) {
+            throw new Error("Repository event routing requires a producer ID.");
+        }
+        const compatibleProducer = RepositoryRoutes.compatibleProducerId(producerId, targetIdField);
+        if (compatibleProducer.compatible) {
+            return RepositoryRoutes.readRouteId(compatibleProducer.id, targetIdField, "event");
+        }
+        return RepositoryRoutes.readRouteId(RepositoryRoutes.readFirstFieldId(message, schema, "event"), targetIdField, "event");
+    },
+    compatibleProducerId(producerId, targetIdField) {
+        const descriptor = targetIdField.descriptor;
+        if (descriptor.fieldKind === "message") {
+            const schema = descriptor.message;
+            if (producerId.typeUrl !== TypeUrls.derive(schema))
+                return { compatible: false };
+            const id = Identifiers.unpack(schema, producerId);
+            if (id === undefined) {
+                throw new Error("Repository event routing requires a readable compatible producer ID.");
+            }
+            return { compatible: true, id };
+        }
+        if (descriptor.fieldKind !== "scalar") {
+            throw new Error("Repository event routing requires a scalar or message-valued ID.");
+        }
+        const type = RepositoryRoutes.primitiveIdentifierType(descriptor.scalar);
+        const schema = type === "string"
+            ? StringValueSchema
+            : type === "int32"
+                ? Int32ValueSchema
+                : Int64ValueSchema;
+        if (producerId.typeUrl !== TypeUrls.derive(schema))
+            return { compatible: false };
+        const id = type === "string"
+            ? Identifiers.unpack("string", producerId)
+            : type === "int32"
+                ? Identifiers.unpack("int32", producerId)
+                : Identifiers.unpack("int64", producerId);
+        if (id === undefined) {
+            throw new Error("Repository event routing requires a readable compatible producer ID.");
+        }
+        return { compatible: true, id };
+    },
+    primitiveIdentifierType(type) {
+        switch (type) {
+            case ScalarType.STRING:
+                return "string";
+            case ScalarType.INT32:
+            case ScalarType.SINT32:
+            case ScalarType.SFIXED32:
+                return "int32";
+            case ScalarType.INT64:
+            case ScalarType.SINT64:
+            case ScalarType.SFIXED64:
+                return "int64";
+            default:
+                throw new Error("Repository event routing requires a supported Entity ID type.");
+        }
+    },
+    readRouteId(value, targetIdField, signalKind) {
+        const descriptor = targetIdField.descriptor;
+        if (descriptor.fieldKind === "message") {
+            return RepositoryRoutes.readMessageRouteId(value, descriptor.message, signalKind);
+        }
+        if (descriptor.fieldKind === "scalar") {
+            return RepositoryRoutes.readPrimitiveRouteId(value, descriptor.scalar, signalKind);
+        }
+        throw new Error(`Repository ${signalKind} routing requires a scalar or message-valued ID.`);
+    },
+    readMessageRouteId(value, targetSchema, signalKind) {
+        const id = MessageIds.read(value);
+        if (id === undefined) {
+            throw new Error(`Repository ${signalKind} routing requires a "${targetSchema.typeName}" ID.`);
+        }
+        if (id.$typeName !== targetSchema.typeName) {
+            throw new Error(`Repository ${signalKind} routing requires a "${targetSchema.typeName}" ID.`);
+        }
+        try {
+            Validate.check(targetSchema, id);
+        }
+        catch (error) {
+            throw new Error(`Repository ${signalKind} routing requires a valid "${targetSchema.typeName}" ID.`, { cause: error });
+        }
+        try {
+            Identifiers.pack(targetSchema, id);
+        }
+        catch (error) {
+            throw new Error(`Repository ${signalKind} routing requires an encodable "${targetSchema.typeName}" ID.`, { cause: error });
+        }
+        return id;
+    },
+    readPrimitiveRouteId(value, targetType, signalKind) {
+        const id = RepositoryRoutes.readCompatiblePrimitiveId(value, targetType);
+        if (id === undefined) {
+            throw new Error(`Repository ${signalKind} routing requires an ID compatible with the Entity state.`);
+        }
+        return id;
+    },
+    readCompatiblePrimitiveId(value, targetType) {
+        switch (targetType) {
+            case ScalarType.STRING:
+                return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+            case ScalarType.INT32:
+            case ScalarType.SINT32:
+            case ScalarType.SFIXED32:
+                return typeof value === "number" &&
+                    Number.isInteger(value) &&
+                    value >= -(2 ** 31) &&
+                    value < 2 ** 31
+                    ? value
+                    : undefined;
+            case ScalarType.INT64:
+            case ScalarType.SINT64:
+            case ScalarType.SFIXED64:
+                return typeof value === "bigint" && value >= -(1n << 63n) && value < 1n << 63n
+                    ? value
+                    : undefined;
+            default:
+                return undefined;
+        }
+    },
+};
+Object.freeze(RepositoryRoutes);
+/**
+ * Internal repository storage operations.
+ */
+const RepositoryStorage = {
+    openEntityStorage(factory, input) {
+        const candidate = factory;
+        if (candidate.createEntityStorage === undefined) {
+            throw new Error("StorageFactory does not provide the required atomic Entity commit storage seam.");
+        }
+        const entity = candidate.createEntityStorage(input);
+        const commits = EntityCommitStorageFactories.create(factory, input);
+        return {
+            ...entity,
+            commits,
+            close: () => {
+                commits.close();
+                entity.close();
+            },
+        };
+    },
+    openRepositoryEntityStorage(repository, factory, input) {
+        const handle = RepositoryStorage.openEntityStorage(factory, input);
+        const key = JSON.stringify({ context: input.context, state: input.sourceType.typeName });
+        let handles = repositoryEntityHandles.get(repository);
+        if (handles === undefined) {
+            handles = new Map();
+            repositoryEntityHandles.set(repository, handles);
+        }
+        const existing = handles.get(key);
+        if (existing !== undefined) {
+            handle.close();
+            return existing;
+        }
+        handles.set(key, handle);
+        return handle;
+    },
+    entityStorageInput(repository, context) {
+        const descriptor = entityStorageDescriptor(context, SpecScanner.scan(repository.entityType));
+        const history = RepositoryStorage.historyConfiguration(repository);
+        return {
+            ...descriptor,
+            stateHistory: history.stateHistory,
+            eventHistory: repository.entityFamily === "aggregate" || history.processManagerEventHistory,
+        };
+    },
+    readHistoryConfiguration(options, family) {
+        const guard = options.doubleDispatchGuard;
+        const depth = guard === true
+            ? 100
+            : guard === false || guard === undefined
+                ? undefined
+                : (guard.depth ?? 100);
+        if (depth !== undefined && (!Number.isSafeInteger(depth) || depth <= 0)) {
+            throw new RangeError("Repository doubleDispatchGuard.depth must be a positive safe integer.");
+        }
+        if (depth !== undefined && family === "projection") {
+            throw new Error("Repository doubleDispatchGuard is unavailable for Projections.");
+        }
+        if (depth !== undefined &&
+            family === "process-manager" &&
+            options.processManagerEventHistory !== true) {
+            throw new Error("Process Manager doubleDispatchGuard requires processManagerEventHistory.");
+        }
+        return {
+            stateHistory: options.stateHistory ?? false,
+            processManagerEventHistory: options.processManagerEventHistory ?? false,
+            dispatchGuardDepth: depth,
+        };
+    },
+    historyConfiguration(repository) {
+        const configuration = repositoryHistoryConfigurations.get(repository);
+        if (configuration === undefined)
+            throw new Error("Repository history configuration is unavailable.");
+        return configuration;
+    },
+    /**
+     * In-process bounded duplicate guard. Completion is recorded only after a successful execution;
+     * therefore provider/journal failures may be retried and separate machines remain independent.
+     */
+};
+Object.freeze(RepositoryStorage);
+/**
+ * Internal repository history internals operations.
+ */
+const RepositoryHistoryInternals = {
+    bindEntityHistory(entity, storage, entityId, schema) {
+        const stateCache = RepositoryHistoryInternals.createHistoryCache((depth, startingFromVersion) => storage.states.backward(entityId, depth, startingFromVersion), (record) => BigInt(EntityRecords.unpack(schema, record).versionMessage.number), { requireDescendingVersions: true });
+        entityStateHistoryCaches.set(entity, stateCache);
+        const eventCache = RepositoryHistoryInternals.createHistoryCache((depth, startingFromVersion) => storage.events.backward(entityId, depth, startingFromVersion), (event) => RepositorySignals.readEventVersion(event), { cacheCompleteVersionGroups: true });
+        entityHistoryAccess.bind(entity, {
+            stateAt: async (time) => RepositoryHistoryInternals.cloneHistoryState(await storage.states.stateAt(entityId, time)),
+            states: async (depth) => RepositoryHistoryInternals.freezeHistoryStates((await stateCache.read(depth)).map((record) => EntityRecords.unpack(schema, record).state)),
+            events: async (depth) => RepositoryHistoryInternals.freezeHistoryEvents(await eventCache.read(depth)),
+            stateMaintenance: storage.states,
+            eventMaintenance: storage.events,
+        });
+    },
+    /**
+     * Creates a per-live-entity continuation cache that serializes a larger request behind a prior read.
+     *
+     * @internal Shared repository history-cache implementation, exercised by repository tests.
+     */
+    createHistoryCache(load, versionOf, options = {}) {
+        return new RepositoryHistoryCache(load, versionOf, options).api();
+    },
+    cloneHistoryState(state) {
+        return state === undefined ? undefined : Object.freeze(structuredClone(state));
+    },
+    freezeHistoryStates(states) {
+        return Object.freeze(states.map((state) => Object.freeze(structuredClone(state))));
+    },
+    freezeHistoryEvents(events) {
+        return Object.freeze(events.map((event) => Object.freeze(clone(EventSchema, event))));
+    },
+};
+Object.freeze(RepositoryHistoryInternals);
+class RepositoryHistoryCache {
+    #load;
+    #versionOf;
+    #requireDescendingVersions;
+    #cacheCompleteVersionGroups;
+    #entries = Object.freeze([]);
+    #exhausted = false;
+    #continuation = Promise.resolve();
+    #nextVersion;
+    #newestVersion;
+    #generation = 0;
+    constructor(load, versionOf, options) {
+        this.#load = load;
+        this.#versionOf = versionOf;
+        this.#requireDescendingVersions = options.requireDescendingVersions ?? false;
+        this.#cacheCompleteVersionGroups = options.cacheCompleteVersionGroups ?? false;
+    }
+    api() {
+        return Object.freeze({
+            read: (depth) => this.read(depth),
+            clear: () => {
+                this.clear();
+            },
+        });
+    }
+    clear() {
+        this.#generation += 1;
+        this.#entries = Object.freeze([]);
+        this.#exhausted = false;
+        this.#nextVersion = undefined;
+        this.#newestVersion = undefined;
+    }
+    async read(depth) {
+        await this.#continuation;
+        if (this.#isSatisfied(depth))
+            return this.#entries.slice(0, depth);
+        let result;
+        const next = this.#continuation.then(async () => {
+            if (this.#isSatisfied(depth))
+                return;
+            result = await this.#extend(depth);
+        });
+        // spine-log-boundary: server.repository_history_prefetch
+        this.#continuation = next.catch(() => undefined);
+        await next;
+        return result ?? this.#entries.slice(0, depth);
+    }
+    #isSatisfied(depth) {
+        return this.#entries.length >= depth || this.#exhausted;
+    }
+    async #extend(depth) {
+        const generation = this.#generation;
+        const requested = Math.max(1, depth - this.#entries.length);
+        return this.#cacheCompleteVersionGroups
+            ? this.#extendCompleteGroups(depth, requested, generation)
+            : this.#extendVersioned(depth, requested, generation);
+    }
+    async #extendCompleteGroups(depth, requested, generation) {
+        const loaded = await this.#load(requested + 1, this.#nextVersion);
+        if (generation !== this.#generation)
+            return undefined;
+        const combined = [...this.#entries, ...loaded];
+        const cacheable = this.#completeGroups(loaded, requested);
+        this.#append(cacheable);
+        this.#exhausted = loaded.length < requested + 1;
+        return Object.freeze(combined.slice(0, depth));
+    }
+    #completeGroups(loaded, requested) {
+        const terminal = loaded.at(-1);
+        const terminalVersion = terminal === undefined ? undefined : this.#versionOf(terminal);
+        const length = loaded.length < requested + 1 || terminalVersion === undefined
+            ? loaded.length
+            : loaded.findIndex((entry) => this.#versionOf(entry) === terminalVersion);
+        return loaded.slice(0, Math.max(0, length));
+    }
+    async #extendVersioned(depth, requested, generation) {
+        const loaded = await this.#load(requested, this.#nextVersion);
+        if (generation !== this.#generation)
+            return undefined;
+        const latest = loaded[0] === undefined ? undefined : this.#versionOf(loaded[0]);
+        if (this.#hasInvalidPage(loaded)) {
+            this.clear();
+            return undefined;
+        }
+        if (this.#hasNewerPage(latest))
+            return this.#refresh(depth, generation);
+        if (this.#hasInvalidContinuation(latest)) {
+            this.clear();
+            return undefined;
+        }
+        this.#append(loaded);
+        this.#newestVersion ??= latest;
+        this.#exhausted = loaded.length < requested;
+        return undefined;
+    }
+    #hasInvalidPage(loaded) {
+        if (!this.#requireDescendingVersions)
+            return false;
+        for (let index = 1; index < loaded.length; index += 1) {
+            const newer = this.#versionOf(loaded[index - 1]);
+            const older = this.#versionOf(loaded[index]);
+            if (newer !== undefined && older !== undefined && newer <= older)
+                return true;
+        }
+        return false;
+    }
+    #hasNewerPage(latest) {
+        return (this.#newestVersion !== undefined &&
+            latest !== undefined &&
+            latest > this.#newestVersion &&
+            this.#nextVersion !== undefined);
+    }
+    #hasInvalidContinuation(latest) {
+        const oldest = this.#entries.at(-1);
+        const oldestVersion = oldest === undefined ? undefined : this.#versionOf(oldest);
+        return (this.#requireDescendingVersions &&
+            oldestVersion !== undefined &&
+            latest !== undefined &&
+            latest >= oldestVersion);
+    }
+    async #refresh(depth, generation) {
+        this.clear();
+        const refreshed = await this.#load(depth);
+        if (generation + 1 !== this.#generation)
+            return undefined;
+        if (this.#hasInvalidPage(refreshed))
+            return undefined;
+        this.#append(refreshed);
+        this.#newestVersion = refreshed[0] === undefined ? undefined : this.#versionOf(refreshed[0]);
+        this.#exhausted = refreshed.length < depth;
+        return undefined;
+    }
+    #append(loaded) {
+        this.#entries = Object.freeze([...this.#entries, ...loaded]);
+        const last = loaded.at(-1);
+        this.#nextVersion = last === undefined ? this.#nextVersion : this.#versionOf(last);
+    }
+}
+/**
+ * Internal dispatch guards operations.
+ */
+const DispatchGuards = {
+    async guardedEntityEventDispatch(repository, runtime, event, entityId, dispatch) {
+        const depth = RepositoryStorage.historyConfiguration(repository).dispatchGuardDepth;
+        const eventId = event.id?.value;
+        if (depth === undefined || eventId === undefined || eventId.length === 0)
+            return dispatch();
+        if (entityId === undefined)
+            return dispatch();
+        const key = DispatchGuards.canonicalEntityIdKey(repository, entityId);
+        const journalEventId = DispatchGuards.guardedJournalEventId(eventId, key);
+        const { guard, guards } = DispatchGuards.guardLane(repository, key);
+        DispatchGuards.touchGuardLane(guards, key);
+        guard.active += 1;
+        return DispatchGuards.scheduleDispatch(repository, runtime, event, entityId, eventId, journalEventId, depth, guard, guards, dispatch);
+    },
+    scheduleDispatch(repository, runtime, event, entityId, eventId, journalEventId, depth, guard, guards, dispatch) {
+        const next = guard.chain.then(() => DispatchGuards.dispatchOnce(repository, runtime, event, entityId, eventId, journalEventId, depth, guard, dispatch));
+        // spine-log-boundary: server.repository_dispatch_guard
+        guard.chain = next
+            .catch(() => undefined)
+            .finally(() => {
+            guard.active -= 1;
+            DispatchGuards.trimGuardLanes(guards, depth);
+        });
+        return next;
+    },
+    guardLane(repository, key) {
+        let guards = repositoryDispatchGuards.get(repository);
+        if (guards === undefined) {
+            guards = { lanes: new Map(), order: [] };
+            repositoryDispatchGuards.set(repository, guards);
+        }
+        let guard = guards.lanes.get(key);
+        if (guard === undefined) {
+            guard = { completed: new Set(), order: [], chain: Promise.resolve(), active: 0 };
+            guards.lanes.set(key, guard);
+        }
+        return { guard, guards };
+    },
+    async dispatchOnce(repository, runtime, event, entityId, eventId, journalEventId, depth, guard, dispatch) {
+        if (guard.completed.has(eventId))
+            return;
+        const storage = RepositoryStorage.openEntityStorage(runtime.storageFactory, RepositoryStorage.entityStorageInput(repository, RepositoryTenants.storageContextForEvent(runtime.context, event)));
+        let persisted;
+        try {
+            persisted = await storage.events.backward(entityId, depth);
+        }
+        finally {
+            storage.close();
+        }
+        if (persisted.some((candidate) => candidate.id?.value === journalEventId)) {
+            DispatchGuards.rememberGuardCompletion(guard, eventId, depth);
+            return;
+        }
+        await dispatch();
+        DispatchGuards.rememberGuardCompletion(guard, eventId, depth);
+    },
+    rememberGuardCompletion(guard, eventId, depth) {
+        if (!guard.completed.has(eventId)) {
+            guard.completed.add(eventId);
+            guard.order.push(eventId);
+        }
+        while (guard.order.length > depth) {
+            const expired = guard.order.shift();
+            if (expired !== undefined)
+                guard.completed.delete(expired);
+        }
+    },
+    touchGuardLane(guards, key) {
+        const index = guards.order.indexOf(key);
+        if (index >= 0)
+            guards.order.splice(index, 1);
+        guards.order.push(key);
+    },
+    trimGuardLanes(guards, depth) {
+        while (guards.order.length > depth) {
+            const index = guards.order.findIndex((key) => guards.lanes.get(key)?.active === 0);
+            if (index < 0)
+                return;
+            const [key] = guards.order.splice(index, 1);
+            if (key === undefined)
+                return;
+            guards.lanes.delete(key);
+        }
+    },
+    guardedJournalEvent(repository, event, entityId) {
+        const sourceId = event.id?.value;
+        if (sourceId === undefined)
+            return event;
+        return create(EventSchema, {
+            ...event,
+            id: create(EventIdSchema, {
+                value: DispatchGuards.guardedJournalEventId(sourceId, DispatchGuards.canonicalEntityIdKey(repository, entityId)),
+            }),
+        });
+    },
+    guardedJournalEventId(sourceId, entityKey) {
+        return `${sourceId}.guard.${encodeURIComponent(entityKey)}`;
+    },
+    canonicalEntityIdKey(repository, id) {
+        return InboxTargets.key(InboxMessages.inboxTargetId(id, repository.idField));
+    },
+};
+Object.freeze(DispatchGuards);
+/**
+ * Internal inbox messages operations.
+ */
+const InboxMessages = {
+    inboxTargetId(entityId, idField) {
+        if (idField.descriptor.fieldKind === "message") {
+            return Identifiers.pack(idField.descriptor.message, entityId);
+        }
+        if (typeof entityId === "string")
+            return Identifiers.pack("string", entityId);
+        if (typeof entityId === "number")
+            return Identifiers.pack("int32", entityId);
+        if (typeof entityId === "bigint")
+            return Identifiers.pack("int64", entityId);
+        throw new Error("Repository Entity Inbox handoff requires a supported target ID.");
+    },
+    targetEntityId(targetId, idField) {
+        const descriptor = idField.descriptor;
+        let entityId;
+        if (descriptor.fieldKind === "message") {
+            entityId = Identifiers.unpack(descriptor.message, targetId);
+        }
+        else if (descriptor.fieldKind === "scalar") {
+            switch (descriptor.scalar) {
+                case ScalarType.STRING:
+                    entityId = Identifiers.unpack("string", targetId);
+                    break;
+                case ScalarType.INT32:
+                case ScalarType.SINT32:
+                case ScalarType.SFIXED32:
+                    entityId = Identifiers.unpack("int32", targetId);
+                    break;
+                case ScalarType.INT64:
+                case ScalarType.SINT64:
+                case ScalarType.SFIXED64:
+                    entityId = Identifiers.unpack("int64", targetId);
+                    break;
+            }
+        }
+        if (entityId === undefined) {
+            throw new Error("Entity Inbox replay stored target ID is incompatible with the repository.");
+        }
+        return RepositoryRoutes.readRouteId(entityId, idField, "command");
+    },
+    readInboxCommand(message) {
+        if (message.label !== "HANDLE_COMMAND") {
+            throw new Error(`Entity Inbox replay does not handle "${message.label}" messages.`);
+        }
+        const command = message.signal === undefined ? undefined : AnyMessages.unpack(message.signal, CommandSchema);
+        if (command === undefined) {
+            throw CommandValidationError.invalidPayload();
+        }
+        return command;
+    },
+    readPmInboxEvent(message) {
+        return InboxMessages.readStoredEvent(message, "REACT_UPON_EVENT", "Entity Inbox replay", "Entity Inbox replay requires a readable stored event.");
+    },
+    readProjectionInboxEvent(message) {
+        return InboxMessages.readStoredEvent(message, "UPDATE_SUBSCRIBER", "Projection inbox replay", "Projection inbox replay requires a readable stored event.");
+    },
+    readStoredEvent(message, expectedLabel, replayName, unreadableMessage) {
+        if (message.label !== expectedLabel) {
+            throw new Error(`${replayName} does not handle "${message.label}" messages.`);
+        }
+        const signal = message.signal === undefined
+            ? undefined
+            : create(AnySchema, {
+                typeUrl: message.signal.typeUrl,
+                value: new Uint8Array(message.signal.value),
+            });
+        const event = signal === undefined ? undefined : AnyMessages.unpack(signal, EventSchema);
+        if (event === undefined) {
+            throw new Error(unreadableMessage);
+        }
+        return event;
+    },
+};
+Object.freeze(InboxMessages);
+/**
+ * Internal inbox replay operations.
+ */
+const InboxReplay = {
+    async replayAggregateCommand(repository, routing, message, deliveryTenantId) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined) {
+            throw new Error("Aggregate inbox replay requires a bound repository runtime.");
+        }
+        if (message.label !== "HANDLE_COMMAND") {
+            throw new Error(`Aggregate inbox replay does not handle "${message.label}" messages.`);
+        }
+        const command = InboxMessages.readInboxCommand(message);
+        InboxReplay.validateReplayTenant(runtime.context, deliveryTenantId, command);
+        InboxReplay.validateReplayedCommandPayload(routing, command);
+        const route = InboxReplay.replayCommandRoute(repository, routing, message, command);
+        return await new AggregateCommandExecution(repository, routing, runtime, command).run(route);
+    },
+    async replayPmInbox(repository, routing, message, deliveryTenantId) {
+        if (message.label === "HANDLE_COMMAND") {
+            return await InboxReplay.replayProcessManagerCommand(repository, routing, message, deliveryTenantId);
+        }
+        if (message.label === "REACT_UPON_EVENT") {
+            await InboxReplay.replayProcessManagerEvent(repository, routing, message, deliveryTenantId);
+            return undefined;
+        }
+        throw new Error(`Entity Inbox replay does not handle "${message.label}" messages.`);
+    },
+    async replayProcessManagerCommand(repository, routing, message, deliveryTenantId) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined) {
+            throw new Error("Entity Inbox replay requires a bound repository runtime.");
+        }
+        const command = InboxMessages.readInboxCommand(message);
+        InboxReplay.validateReplayTenant(runtime.context, deliveryTenantId, command);
+        InboxReplay.validateReplayedCommandPayload(routing, command);
+        const route = InboxReplay.replayCommandRoute(repository, routing, message, command);
+        return await new ProcessManagerCommandExecution(repository, routing, runtime, command).run(route);
+    },
+    async replayProcessManagerEvent(repository, routing, message, deliveryTenantId) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined) {
+            throw new Error("Entity Inbox replay requires a bound repository runtime.");
+        }
+        const event = InboxMessages.readPmInboxEvent(message);
+        InboxReplay.validatePmReplayTenant(runtime.context, deliveryTenantId, event);
+        InboxReplay.validateReplayedEventPayload(routing, event, "Entity Inbox replay requires a readable event payload.");
+        const route = InboxReplay.replayEventRoute(repository, routing, message, event, "Entity Inbox replay");
+        const [entityId] = route.entityIds;
+        await new ProcessManagerEventExecution(repository, routing, runtime, event).runTarget(entityId, route);
+    },
+    async replayProjectionEvent(repository, routing, message, deliveryTenantId) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined) {
+            throw new Error("Projection inbox replay requires a bound repository runtime.");
+        }
+        const event = InboxMessages.readProjectionInboxEvent(message);
+        InboxReplay.validateProjectionReplayTenant(runtime.context, deliveryTenantId, event);
+        InboxReplay.validateReplayedEventPayload(routing, event);
+        const route = InboxReplay.replayEventRoute(repository, routing, message, event, "Projection inbox replay");
+        const [entityId] = route.entityIds;
+        await new ProjectionEventExecution(repository, routing, runtime, event).runTarget(entityId, route);
+    },
+    async replayProjectionMessage(repository, routing, message, deliveryTenantId) {
+        const event = InboxMessages.readProjectionInboxEvent(message);
+        if (event.message?.typeUrl === TypeUrls.derive(EntityLog.EntityStateChangedSchema)) {
+            await InboxReplay.replayProjectionStateUpdate(repository, routing, message, event, deliveryTenantId);
+            return;
+        }
+        await InboxReplay.replayProjectionEvent(repository, routing, message, deliveryTenantId);
+    },
+    async replayProjectionStateUpdate(repository, routing, message, event, deliveryTenantId) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined)
+            throw new Error("Projection inbox replay requires a bound repository runtime.");
+        InboxReplay.validateProjectionReplayTenant(runtime.context, deliveryTenantId, event);
+        const route = InboxReplay.replayStateUpdateRoute(repository, routing, message, event);
+        const [entityId] = route.entityIds;
+        const subscribers = route.subscribers;
+        await ProjectionEventExecution.runStateTarget(repository, routing, runtime, event, entityId, route, subscribers);
+    },
+    validateReplayedCommandPayload(routing, command) {
+        const commandMessage = EntityInvocation.requireSignalMessage(command.message, "command");
+        const commandSchema = RepositoryRoutes.schemaForTypeUrl(routing.commandSchemas, commandMessage.typeUrl, "command");
+        const payload = AnyMessages.unpack(commandMessage, commandSchema);
+        if (payload === undefined) {
+            throw CommandValidationError.invalidPayload();
+        }
+        try {
+            Validate.check(commandSchema, payload);
+        }
+        catch (error) {
+            if (error instanceof ValidationException) {
+                throw new CommandValidationError(error.asMessage());
+            }
+            throw error;
+        }
+        const implicitId = ImplicitRequiredIds.validateCommand(commandSchema, payload);
+        if (!implicitId.valid) {
+            throw new CommandValidationError(implicitId.error);
+        }
+    },
+    validateReplayedEventPayload(routing, event, invalidPayloadMessage = "Projection inbox replay requires a readable event payload.") {
+        const eventMessage = EntityInvocation.requireSignalMessage(event.message, "event");
+        const eventSchema = RepositoryRoutes.schemaForTypeUrl(routing.eventSchemas, eventMessage.typeUrl, "event");
+        const payload = AnyMessages.unpack(eventMessage, eventSchema);
+        if (payload === undefined) {
+            throw new Error(invalidPayloadMessage);
+        }
+        Validate.check(eventSchema, payload);
+    },
+    validateReplayTenant(context, deliveryTenantId, command) {
+        if (!context.multitenant) {
+            return;
+        }
+        if (deliveryTenantId === undefined) {
+            throw new Error(`Multitenant Entity Inbox replay for "${context.name}" requires tenantId.`);
+        }
+        const envelopeTenantId = RepositoryTenants.readCommandTenant(command);
+        if (envelopeTenantId === undefined) {
+            throw new Error("Entity Inbox replay requires stored command tenant metadata.");
+        }
+        if (!RepositoryTenants.equal(envelopeTenantId, deliveryTenantId)) {
+            throw new Error("Entity Inbox replay stored command tenant does not match.");
+        }
+    },
+    validateProjectionReplayTenant(context, deliveryTenantId, event) {
+        if (!context.multitenant) {
+            return;
+        }
+        if (deliveryTenantId === undefined) {
+            throw new Error(`Multitenant projection inbox replay for "${context.name}" requires tenantId.`);
+        }
+        const envelopeTenantId = RepositoryTenants.readEventTenant(event);
+        if (envelopeTenantId === undefined) {
+            throw new Error("Projection inbox replay requires stored event tenant metadata.");
+        }
+        if (!RepositoryTenants.equal(envelopeTenantId, deliveryTenantId)) {
+            throw new Error("Projection inbox replay stored event tenant does not match.");
+        }
+    },
+    validatePmReplayTenant(context, deliveryTenantId, event) {
+        if (!context.multitenant) {
+            return;
+        }
+        if (deliveryTenantId === undefined) {
+            throw new Error(`Multitenant Entity Inbox replay for "${context.name}" requires tenantId.`);
+        }
+        const envelopeTenantId = RepositoryTenants.readEventTenant(event);
+        if (envelopeTenantId === undefined) {
+            throw new Error("Entity Inbox replay requires stored event tenant metadata.");
+        }
+        if (!RepositoryTenants.equal(envelopeTenantId, deliveryTenantId)) {
+            throw new Error("Entity Inbox replay stored event tenant does not match.");
+        }
+    },
+    replayCommandRoute(repository, routing, message, command) {
+        const expectedTargetTypeUrl = TypeUrls.derive(repository.stateSchema);
+        if (message.inboxId.targetTypeUrl !== expectedTargetTypeUrl) {
+            throw new Error("Entity Inbox replay stored target type does not match the routed repository.");
+        }
+        const commandMessage = EntityInvocation.requireSignalMessage(command.message, "command");
+        const schema = RepositoryRoutes.schemaForTypeUrl(routing.commandSchemas, commandMessage.typeUrl, "command");
+        return Object.freeze({
+            entityId: InboxMessages.targetEntityId(message.inboxId.targetId, repository.idField),
+            messageFullTypeName: schema.typeName,
+            invocation: "deferred",
+        });
+    },
+    replayEventRoute(repository, routing, message, event, replayName) {
+        const expectedTargetTypeUrl = TypeUrls.derive(repository.stateSchema);
+        if (message.inboxId.targetTypeUrl !== expectedTargetTypeUrl) {
+            throw new Error(`${replayName} stored target type does not match the routed repository.`);
+        }
+        const eventMessage = EntityInvocation.requireSignalMessage(event.message, "event");
+        const schema = RepositoryRoutes.schemaForTypeUrl(routing.eventSchemas, eventMessage.typeUrl, "event");
+        const entityId = InboxMessages.targetEntityId(message.inboxId.targetId, repository.idField);
+        const entityIds = Object.freeze([entityId]);
+        return Object.freeze({
+            entityIds,
+            messageFullTypeName: schema.typeName,
+            invocation: "deferred",
+        });
+    },
+    replayStateUpdateRoute(repository, routing, message, event) {
+        const expectedTargetTypeUrl = TypeUrls.derive(repository.stateSchema);
+        if (message.inboxId.targetTypeUrl !== expectedTargetTypeUrl) {
+            throw new Error("Projection inbox replay stored target type does not match the routed repository.");
+        }
+        const update = RepositoryRoutes.decodeStateUpdate(event, routing.stateSchemas, "Projection inbox replay");
+        if (update === undefined ||
+            (routing.stateSubscriptions.get(update.schema.typeName)?.length ?? 0) === 0) {
+            throw new Error("Projection inbox replay requires a readable stored Entity state update.");
+        }
+        const { schema, state } = update;
+        const entityId = InboxMessages.targetEntityId(message.inboxId.targetId, repository.idField);
+        const entityIds = Object.freeze([entityId]);
+        return Object.freeze({
+            entityIds,
+            messageFullTypeName: schema.typeName,
+            state,
+            subscribers: Object.freeze((() => {
+                const candidates = routing.stateSubscriptions.get(schema.typeName) ?? [];
+                return candidates.filter((subscriber) => (subscriber.handler.origin === "external") === (event.context?.external === true));
+            })()),
+            invocation: "deferred",
+        });
+    },
+};
+Object.freeze(InboxReplay);
+/**
+ * Internal inbox handoff operations.
+ */
+const InboxHandoff = {
+    async handoffEntityCommand(repository, runtime, command) {
+        const route = repository.routeCommand(command);
+        const commandId = RepositorySignals.requireCommandId(command);
+        const whenReceived = new Date();
+        const keepUntil = new Date(whenReceived.getTime() + inboxDedupMs);
+        const deliveryTenantId = RepositoryTenants.requireCommandTenant(runtime.context, command);
+        const delivery = new Delivery({
+            context: RepositoryTenants.entityInboxDeliveryContext(runtime.context, deliveryTenantId),
+            storageFactory: runtime.storageFactory,
+            strategy: runtime.entityInbox.strategy(),
+        });
+        await runtime.entityInbox.receive(delivery, {
+            inboxId: {
+                targetId: InboxMessages.inboxTargetId(route.entityId, repository.idField),
+                targetTypeUrl: TypeUrls.derive(repository.stateSchema),
+            },
+            signalId: commandId.uuid,
+            signal: AnyMessages.pack(CommandSchema, command, { validate: false }),
+            label: "HANDLE_COMMAND",
+            status: "TO_DELIVER",
+            keepUntil,
+        }, deliveryTenantId);
+    },
+    async handoffProjectionEvent(repository, runtime, event, entityId) {
+        const eventId = RepositorySignals.requireEventId(event);
+        const whenReceived = new Date();
+        const keepUntil = new Date(whenReceived.getTime() + inboxDedupMs);
+        const deliveryTenantId = RepositoryTenants.requireProjectionTenant(runtime.context, event);
+        const delivery = new Delivery({
+            context: RepositoryTenants.projectionDeliveryContext(runtime.context, deliveryTenantId),
+            storageFactory: runtime.storageFactory,
+        });
+        await runtime.projectionInbox.receive(delivery, {
+            inboxId: {
+                targetId: InboxMessages.inboxTargetId(entityId, repository.idField),
+                targetTypeUrl: TypeUrls.derive(repository.stateSchema),
+            },
+            signalId: eventId.value,
+            signal: AnyMessages.pack(EventSchema, event, { validate: false }),
+            label: "UPDATE_SUBSCRIBER",
+            status: "TO_DELIVER",
+            shard: ShardIndex.single(),
+            keepUntil,
+        }, deliveryTenantId);
+    },
+    async handoffPmEvent(repository, runtime, event, entityId) {
+        const eventId = RepositorySignals.requireEventId(event);
+        const whenReceived = new Date();
+        const keepUntil = new Date(whenReceived.getTime() + inboxDedupMs);
+        const deliveryTenantId = RepositoryTenants.requirePmEventTenant(runtime.context, event);
+        const delivery = new Delivery({
+            context: RepositoryTenants.entityInboxDeliveryContext(runtime.context, deliveryTenantId),
+            storageFactory: runtime.storageFactory,
+            strategy: runtime.entityInbox.strategy(),
+        });
+        await runtime.entityInbox.receive(delivery, InboxHandoff.pmEventInboxInput(repository, eventId.value, event, entityId, keepUntil), deliveryTenantId);
+    },
+    async handoffPmEvents(repository, runtime, event, entityIds) {
+        const eventId = RepositorySignals.requireEventId(event);
+        const whenReceived = new Date();
+        const keepUntil = new Date(whenReceived.getTime() + inboxDedupMs);
+        const deliveryTenantId = RepositoryTenants.requirePmEventTenant(runtime.context, event);
+        const delivery = new Delivery({
+            context: RepositoryTenants.entityInboxDeliveryContext(runtime.context, deliveryTenantId),
+            storageFactory: runtime.storageFactory,
+            strategy: runtime.entityInbox.strategy(),
+        });
+        const inputs = entityIds.map((entityId) => InboxHandoff.pmEventInboxInput(repository, eventId.value, event, entityId, keepUntil));
+        await runtime.entityInbox.receiveAll(delivery, inputs, deliveryTenantId);
+    },
+    pmEventInboxInput(repository, signalId, event, entityId, keepUntil) {
+        return {
+            inboxId: {
+                targetId: InboxMessages.inboxTargetId(entityId, repository.idField),
+                targetTypeUrl: TypeUrls.derive(repository.stateSchema),
+            },
+            signalId,
+            signal: AnyMessages.pack(EventSchema, event, { validate: false }),
+            label: "REACT_UPON_EVENT",
+            status: "TO_DELIVER",
+            keepUntil,
+        };
+    },
+};
+Object.freeze(InboxHandoff);
+/**
+ * Internal repository dispatch operations.
+ */
+const RepositoryDispatch = {
+    createRepositoryDispatchers(repository, routing) {
+        const acceptedEventRoutes = new WeakMap();
+        const acceptedStateRoutes = new WeakMap();
+        return Object.freeze({
+            command: RepositoryDispatch.commandDispatcher(repository, routing),
+            event: RepositoryDispatch.eventDispatcher(repository, routing, acceptedEventRoutes),
+            systemEvent: RepositoryDispatch.stateDispatcher(repository, routing, acceptedStateRoutes),
+        });
+    },
+    commandDispatcher(repository, routing) {
+        return routing.commandSchemas.length === 0
+            ? undefined
+            : Object.freeze({
+                messageSchemas: () => routing.commandSchemas,
+                dispatch: (command) => RepositoryDispatch.dispatchRepositoryCommand(repository, routing, command),
+            });
+    },
+    eventDispatcher(repository, routing, accepted) {
+        if (routing.eventSchemas.length === 0)
+            return undefined;
+        const dispatcher = Object.freeze({
+            messageSchemas: () => routing.eventSchemas,
+            externalEventSchemas: () => routing.externalEventSchemas,
+            accept: (event) => {
+                accepted.set(event, repository.routeEvent(event));
+                return Promise.resolve();
+            },
+            dispatch: (event) => {
+                const route = accepted.get(event);
+                accepted.delete(event);
+                return RepositoryDispatch.dispatchRepositoryEvent(repository, routing, event, route);
+            },
+        });
+        return EventDispatcherOriginSchemas.define(dispatcher, routing.domesticEventSchemas, routing.externalEventSchemas);
+    },
+    stateDispatcher(repository, routing, accepted) {
+        if (routing.stateSchemas.length === 0)
+            return undefined;
+        const hasOrigin = (origin) => [...routing.stateSubscriptions.values()].some((values) => values.some((value) => value.handler.origin === origin));
+        const schema = EntityLog.EntityStateChangedSchema;
+        const dispatcher = Object.freeze({
+            messageSchemas: () => Object.freeze([schema]),
+            externalEventSchemas: () => (hasOrigin("external") ? [schema] : []),
+            accept: (event) => {
+                accepted.set(event, routing.routeStateUpdate(event) ?? null);
+                return Promise.resolve();
+            },
+            dispatch: (event) => RepositoryDispatch.dispatchAcceptedState(repository, routing, event, accepted),
+        });
+        return EventDispatcherOriginSchemas.define(dispatcher, hasOrigin("domestic") ? [schema] : [], hasOrigin("external") ? [schema] : []);
+    },
+    dispatchAcceptedState(repository, routing, event, accepted) {
+        const route = accepted.get(event);
+        accepted.delete(event);
+        return route === null
+            ? Promise.resolve()
+            : RepositoryDispatch.dispatchRepositoryStateUpdate(repository, routing, event, route);
+    },
+    createEntityInboxTarget(repository, routing) {
+        if ((repository.entityFamily !== "aggregate" && repository.entityFamily !== "process-manager") ||
+            (routing.commandSchemas.length === 0 && routing.eventSchemas.length === 0)) {
+            return undefined;
+        }
+        return Object.freeze({
+            targetTypeUrl: TypeUrls.derive(repository.stateSchema),
+            labels: Object.freeze([
+                ...(routing.commandSchemas.length === 0 ? [] : ["HANDLE_COMMAND"]),
+                ...(repository.entityFamily === "process-manager" && routing.eventSchemas.length > 0
+                    ? ["REACT_UPON_EVENT"]
+                    : []),
+            ]),
+            replay: (message, deliveryTenantId) => repository.entityFamily === "aggregate"
+                ? InboxReplay.replayAggregateCommand(repository, routing, message, deliveryTenantId)
+                : InboxReplay.replayPmInbox(repository, routing, message, deliveryTenantId),
+        });
+    },
+    createProjectionInboxTarget(repository, routing) {
+        if (repository.entityFamily !== "projection" ||
+            (routing.eventSchemas.length === 0 && routing.stateSchemas.length === 0)) {
+            return undefined;
+        }
+        return Object.freeze({
+            targetTypeUrl: TypeUrls.derive(repository.stateSchema),
+            replay: (message, deliveryTenantId) => InboxReplay.replayProjectionMessage(repository, routing, message, deliveryTenantId),
+        });
+    },
+    createProjectionDirectDispatch(repository, routing) {
+        return (event, rebuild) => {
+            const runtime = repositoryRuntimes.get(repository);
+            if (runtime === undefined) {
+                void repository.routeEvent(event);
+                return Promise.resolve();
+            }
+            return new ProjectionEventExecution(repository, routing, runtime, event, rebuild).runDirect();
+        };
+    },
+    async dispatchRepositoryEvent(repository, routing, event, acceptedRoute) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined) {
+            if (acceptedRoute === undefined)
+                void repository.routeEvent(event);
+            return;
+        }
+        const route = acceptedRoute ?? repository.routeEvent(event);
+        switch (repository.entityFamily) {
+            case "aggregate":
+                await RepositoryDispatch.dispatchAggregateEvent(repository, routing, runtime, event, route);
+                return;
+            case "process-manager":
+                await new ProcessManagerEventExecution(repository, routing, runtime, event).run(route);
+                return;
+            case "projection":
+                await new ProjectionEventExecution(repository, routing, runtime, event).run(route);
+                return;
+        }
+    },
+    async dispatchAggregateEvent(repository, routing, runtime, event, route) {
+        const execution = new AggregateEventExecution(repository, routing, runtime, event);
+        for (const entityId of route.entityIds) {
+            await DispatchGuards.guardedEntityEventDispatch(repository, runtime, event, entityId, () => execution.runTarget(entityId, route));
+        }
+    },
+    async dispatchRepositoryStateUpdate(repository, routing, event, acceptedRoute) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined) {
+            if (acceptedRoute === undefined)
+                void routing.routeStateUpdate(event);
+            return;
+        }
+        const route = acceptedRoute ?? routing.routeStateUpdate(event);
+        if (route === undefined)
+            return;
+        for (const entityId of route.entityIds) {
+            await InboxHandoff.handoffProjectionEvent(repository, runtime, event, entityId);
+        }
+    },
+    async dispatchRepositoryCommand(repository, routing, command) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined) {
+            void repository.routeCommand(command);
+            return;
+        }
+        if (repository.entityFamily === "aggregate") {
+            await InboxHandoff.handoffEntityCommand(repository, runtime, command);
+            return;
+        }
+        if (repository.entityFamily === "process-manager") {
+            await InboxHandoff.handoffEntityCommand(repository, runtime, command);
+            return;
+        }
+        void repository.routeCommand(command);
+    },
+};
+Object.freeze(RepositoryDispatch);
+/**
+ * Defines continuation-aware repository history caches.
+ */
+const repositoryHistory = {
+    // prettier-ignore
+    /**
+     * 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 strictly descending-version and complete-group behavior.
+     * @returns A cache with read and clear operations.
+     */
+    createCache(load, versionOf, options = {}) {
+        return RepositoryHistoryInternals.createHistoryCache(load, versionOf, options);
+    },
+};
+Object.freeze(repositoryHistory);
+/**
+ * Defines continuation-aware repository history caches.
+ */
+export const RepositoryHistory = repositoryHistory;
+//# sourceMappingURL=repository.js.map