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

package/dist/repository/repository.js

@@ -11,17 +11,20 @@
  * 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 { 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 { EntityRecordSchema, } from "@spine-event-engine/proto/generated/spine/server/entity/entity_pb.js";
+import { StorageQueryPolicy, } 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 { ServerEnvironment, serverEnvironmentAccess } from "../server/server-environment.js";
+import { emitServerWarning } from "../server/server-log.js";
 import { CommandRoutingInternals, } from "./command-routing.js";
 import { EventRoutingInternals } from "./event-routing.js";
 import { StateUpdateRoutingInternals, } from "./state-update-routing.js";
@@ -34,12 +37,14 @@ 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 { repositorySpecScanner } 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 { RegisteredTargets } from "../services/registered-targets.js";
+import { EffectiveTenants } from "../context/effective-tenant.js";
 import { HandlerMetadataRegistry, HandlerMetadataValues, } from "../handler/handler-metadata.js";
 import { DeclaredRejections } from "../handler/declared-rejections.js";
 import { standAccess } from "../stand/stand.js";
@@ -93,6 +98,7 @@ export class Repository {
      */
     constructor(options) {
         const { entityType, entityFamily, schema, metadata } = RepositoryIdentity.describeOptions(options);
+        RepositoryRoutes.requireRoutingEntities(entityType, options);
         attachEntitySchema(entityType, schema);
         this.#entityType = entityType;
         this.#entityFamily = entityFamily;
@@ -186,7 +192,7 @@ export class Repository {
      * @returns The calculated command route.
      */
     routeCommand(command) {
-        return this.#routing.routeCommand(command);
+        return RepositoryRoutingReads.call(this, RepositoryTenants.readCommandTenant(command), (reads) => this.#routing.routeCommand(command, reads));
     }
     /**
      * Routes an Event without invoking a handler.
@@ -201,7 +207,10 @@ export class Repository {
      * @returns The calculated event route.
      */
     routeEvent(event) {
-        return this.#routing.routeEvent(event);
+        return RepositoryRoutingReads.call(this, RepositoryTenants.readEventTenant(event), (reads) => this.#routing.routeEvent(event, reads)).then((route) => {
+            RepositoryRoutes.warnLargeRoute(route.messageFullTypeName, this.stateFullTypeName, route.entityIds.length);
+            return route;
+        });
     }
 }
 const repositorySnapshots = new WeakMap();
@@ -355,7 +364,11 @@ export const repositoryAccess = Object.freeze({
         if (routing === undefined) {
             throw new TypeError("State-update routing requires a Repository instance.");
         }
-        return routing.routeStateUpdate(event);
+        return RepositoryRoutingReads.call(repository, RepositoryTenants.readEventTenant(event), (reads) => routing.routeStateUpdate(event, reads)).then((route) => {
+            if (route !== undefined)
+                RepositoryRoutes.warnLargeRoute(route.messageFullTypeName, repository.stateSchema.typeName, route.entityIds.length);
+            return route;
+        });
     },
     /**
      * Looks up the Aggregate or Process Manager inbox replay target.
@@ -436,6 +449,223 @@ const RepositoryCreation = {
         throw new TypeError(`Repository onCreate must synchronously return a ${entityType.name} instance.`);
     },
 };
+/**
+ * Binds repository queries to a single routing invocation's tenant and lifetime.
+ * Routing integration closes the returned access after its callback settles.
+ *
+ * @internal
+ */
+export const repositoryReadAccess = Object.freeze({
+    /**
+     * Creates read-only access for a registered repository with an active runtime.
+     *
+     * @typeParam EntityType The receiving repository's application Entity class.
+     * @param repository Receiving repository.
+     * @param tenantId Tenant carried by the incoming signal, if multitenant.
+     * @returns Bound reads and a close operation for the invocation boundary.
+     */
+    bind(repository, tenantId) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined)
+            throw new Error("Repository reads require an active runtime binding.");
+        return new RepositoryReadScope(repository, runtime, tenantId);
+    },
+});
+/**
+ * Keeps route-local read access alive until an asynchronous callback settles.
+ */
+const RepositoryRoutingReads = {
+    /**
+     * Invokes routing with the signal tenant and closes its read scope afterward.
+     *
+     * @typeParam Result Completed route result.
+     * @param repository Receiving repository.
+     * @param tenantId Signal tenant, when present.
+     * @param callback Route computation using read-only repository access.
+     * @returns Completed route result.
+     */
+    async call(repository, tenantId, callback) {
+        const scope = repositoryRuntimes.has(repository)
+            ? repositoryReadAccess.bind(repository, tenantId)
+            : undefined;
+        const reads = scope ?? this.unbound();
+        try {
+            return await callback(reads);
+        }
+        finally {
+            scope?.close();
+        }
+    },
+    /**
+     * Rejects reads when a route is invoked before repository runtime binding.
+     *
+     * @returns Read operations that report the missing runtime.
+     */
+    unbound() {
+        const unavailable = () => Promise.reject(new Error("Repository reads require an active runtime binding."));
+        return { findIds: unavailable, findStates: unavailable, find: unavailable };
+    },
+};
+/**
+ * Executes read-only queries within one receiving repository and tenant scope.
+ *
+ * @typeParam EntityType Registered application Entity class.
+ */
+class RepositoryReadScope {
+    #repository;
+    #runtime;
+    #context;
+    #active = true;
+    /**
+     * Captures the runtime and validates the incoming signal's effective tenant.
+     *
+     * @param repository Receiving repository.
+     * @param runtime Active repository runtime.
+     * @param tenantId Tenant from the signal, when the context is multitenant.
+     */
+    constructor(repository, runtime, tenantId) {
+        this.#repository = repository;
+        this.#runtime = runtime;
+        this.#context = RepositoryTenants.storageContextForTenant(runtime.context, tenantId);
+    }
+    /**
+     * Reads the typed IDs of all matching current records.
+     *
+     * @param query Description for the registered state schema.
+     * @returns Matching IDs in query order.
+     */
+    async findIds(query) {
+        return (await this.read(query)).map((entry) => entry.id);
+    }
+    /**
+     * Returns cloned complete states from matching current records.
+     *
+     * @param query Description for the registered state schema.
+     * @returns Independent generated state messages in query order.
+     */
+    async findStates(query) {
+        const schema = this.#repository.stateSchema;
+        return (await this.read(query)).map((entry) => clone(schema, EntityRecords.unpack(schema, entry.record).state));
+    }
+    /**
+     * Restores each matching application Entity through the repository hook.
+     *
+     * @param query Description for the registered state schema.
+     * @returns Instances with stored Version and lifecycle flags.
+     */
+    async find(query) {
+        const repository = this.#repository;
+        return (await this.read(query)).map((entry) => {
+            const stored = EntityRecords.unpack(repository.stateSchema, entry.record);
+            return RepositoryCreation.create(repository, {
+                id: entry.id,
+                schema: repository.stateSchema,
+                state: clone(repository.stateSchema, stored.state),
+                version: stored.versionMessage,
+                lifecycle: { archived: stored.archived, deleted: stored.deleted },
+            });
+        });
+    }
+    /**
+     * Closes this routing invocation's read access to new operations.
+     */
+    close() {
+        this.#active = false;
+    }
+    /**
+     * Reads current storage with the complete normalized plan.
+     *
+     * @param query Description for the registered state schema.
+     * @returns Matching stored records and typed IDs.
+     */
+    async read(query) {
+        if (!this.#active || repositoryRuntimes.get(this.#repository) !== this.#runtime)
+            throw new Error("Repository read access has finished.");
+        if (query.schema !== this.#repository.stateSchema)
+            throw new TypeError("Repository query must select the receiving Entity state schema.");
+        const plan = RepositoryReadPredicates.plan(query.buildPlan());
+        const storage = RepositoryStorage.openReadEntityStorage(this.#runtime.storageFactory, RepositoryStorage.entityStorageInput(this.#repository, this.#context));
+        try {
+            return await storage.current.query(plan);
+        }
+        finally {
+            storage.close();
+        }
+    }
+}
+/**
+ * Applies repository lifecycle defaults only when IDs and lifecycle filters are absent.
+ */
+const RepositoryReadPredicates = {
+    /**
+     * Builds an exhaustive normalized plan and validates it before provider access.
+     *
+     * @param compiled Storage-neutral query plan from the shared description.
+     * @returns Plan with repository lifecycle selection and explicit application bounds.
+     */
+    plan(compiled) {
+        const predicate = this.flattenConjunctions(this.withLifecycleDefault(compiled.predicate));
+        const plan = {
+            predicate,
+            ...(compiled.order === undefined ? {} : { order: compiled.order }),
+            ...(compiled.limit === undefined ? {} : { limit: compiled.limit }),
+            exhaustive: true,
+        };
+        StorageQueryPolicy.validate(plan, {
+            comparisons: ["equal", "greaterThan", "lessThan", "greaterOrEqual", "lessOrEqual"],
+            features: ["either", "nested", "order", "limit"],
+        });
+        return plan;
+    },
+    /**
+     * Adds active-record filters when no ID or lifecycle clause occurs in the tree.
+     *
+     * @param predicate Compiled query predicate, when present.
+     * @returns Predicate selected for repository reads.
+     */
+    withLifecycleDefault(predicate) {
+        if (predicate !== undefined && this.explicitSelection(predicate))
+            return predicate;
+        const active = [
+            { kind: "comparison", column: "archived", operator: "equal", value: false },
+            { kind: "comparison", column: "deleted", operator: "equal", value: false },
+        ];
+        return {
+            kind: "all",
+            predicates: predicate === undefined ? active : [predicate, ...active],
+        };
+    },
+    /**
+     * Normalizes adjacent conjunctions so providers that require flat filters can admit them.
+     *
+     * @param predicate Compiled predicate after lifecycle selection.
+     * @returns Equivalent predicate with no directly nested conjunctions.
+     */
+    flattenConjunctions(predicate) {
+        if (predicate.kind === "comparison" || predicate.kind === "ids")
+            return predicate;
+        const children = predicate.predicates.map((child) => this.flattenConjunctions(child));
+        return {
+            kind: predicate.kind,
+            predicates: predicate.kind === "all"
+                ? children.flatMap((child) => (child.kind === "all" ? child.predicates : [child]))
+                : children,
+        };
+    },
+    /**
+     * Checks for an explicit ID or lifecycle clause at any predicate depth.
+     *
+     * @param predicate Compiled predicate to inspect.
+     * @returns Whether the application selected IDs or lifecycle state explicitly.
+     */
+    explicitSelection(predicate) {
+        if (predicate.kind === "ids")
+            return true;
+        if (predicate.kind === "comparison")
+            return predicate.column === "archived" || predicate.column === "deleted";
+        return predicate.predicates.some((child) => this.explicitSelection(child));
+    },
+};
 /**
  * Loads and persists Aggregate state within one tenant storage context.
  */
@@ -512,11 +742,9 @@ class AggregateExecutionSupport {
         const lifecycle = RepositoryEntities.repositoryLifecycle(loaded.entity);
         const state = RepositoryEntities.repositoryState(loaded.entity);
         const versionMessage = RepositoryEntities.repositoryVersion(loaded.entity);
-        const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(this.#storageContext.tenantId, versionMessage, lifecycle));
+        const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(this.#storageContext.tenantId, versionMessage, lifecycle), this.#repository.metadata);
         try {
-            const outcome = await this.#commitAggregateRecord(loaded, entityId, state, versionMessage, lifecycle, events, diagnostics);
-            if (outcome !== "committed")
-                throw new Error("Concurrent Aggregate state commit conflict.");
+            await this.#commitAggregateRecord(loaded, entityId, events, diagnostics, deferred);
             entityStateHistoryCaches.get(loaded.entity)?.clear();
         }
         catch (error) {
@@ -547,20 +775,17 @@ class AggregateExecutionSupport {
      *
      * @param loaded Loaded Aggregate and commit storage.
      * @param entityId Aggregate identifier.
-     * @param state Accepted Aggregate state.
-     * @param version Current Spine Version.
-     * @param lifecycle Accepted lifecycle flags.
      * @param events Produced Events to retain and publish.
      * @param diagnostics Events to retain in the diagnostic history.
-     * @returns The storage commit outcome.
+     * @param deferred Stand update containing the prepared record.
+     * @returns Completion after the storage commit.
      */
-    #commitAggregateRecord(loaded, entityId, state, version, lifecycle, events, diagnostics) {
-        const record = EntityRecords.pack(this.#repository.stateSchema, entityId, state, version, lifecycle);
+    #commitAggregateRecord(loaded, entityId, events, diagnostics, deferred) {
+        const record = RepositoryStand.preparedRecord(this.#repository, deferred, entityId);
         return loaded.commits.commit({
             context: this.#storageContext,
             entity: loaded.storageInput,
             entityId,
-            ...(loaded.current === undefined ? {} : { expected: loaded.current }),
             next: record,
             ...(RepositoryStorage.historyConfiguration(this.#repository).stateHistory
                 ? { states: [record] }
@@ -670,7 +895,7 @@ class AggregateCommandExecution {
      */
     async run(replayedRoute) {
         void RepositorySignals.requireCommandId(this.#command);
-        const intake = this.#readIntake(replayedRoute);
+        const intake = await this.#readIntake(replayedRoute);
         if (intake === undefined)
             return undefined;
         return this.#runAssignee(intake);
@@ -681,11 +906,11 @@ class AggregateCommandExecution {
      * @param replayedRoute Accepted inbox route, when present.
      * @returns Decoded message and route with an assignee, or `undefined`.
      */
-    #readIntake(replayedRoute) {
+    async #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 route = replayedRoute ?? (await this.#repository.routeCommand(this.#command));
         const assignee = this.#routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
         return assignee === undefined ? undefined : Object.freeze({ message, route, assignee });
     }
@@ -1077,7 +1302,7 @@ class ProjectionEventExecution {
      * @returns Completion after inbox handoff.
      */
     async run(acceptedRoute) {
-        const intake = this.#readIntake(acceptedRoute);
+        const intake = await this.#readIntake(acceptedRoute);
         if (intake.subscribers.length === 0) {
             return;
         }
@@ -1093,7 +1318,7 @@ class ProjectionEventExecution {
      * @returns Completion after target delivery.
      */
     async runTarget(entityId, acceptedRoute) {
-        const intake = this.#readIntake(acceptedRoute);
+        const intake = await this.#readIntake(acceptedRoute);
         if (intake.subscribers.length === 0) {
             return;
         }
@@ -1106,7 +1331,7 @@ class ProjectionEventExecution {
      * @returns Completion after all targets receive the Event.
      */
     async runDirect(acceptedRoute) {
-        const intake = this.#readIntake(acceptedRoute);
+        const intake = await this.#readIntake(acceptedRoute);
         if (intake.subscribers.length === 0) {
             return;
         }
@@ -1154,8 +1379,8 @@ class ProjectionEventExecution {
      * @param acceptedRoute Route accepted before delivery, when present.
      * @returns Route and matching subscribers.
      */
-    #readIntake(acceptedRoute) {
-        const route = acceptedRoute ?? this.#repository.routeEvent(this.#event);
+    async #readIntake(acceptedRoute) {
+        const route = acceptedRoute ?? (await 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");
@@ -1182,8 +1407,8 @@ class ProjectionEventExecution {
         const state = RepositoryEntities.repositoryState(loaded.entity);
         const version = RepositoryEntities.repositoryVersion(loaded.entity);
         const lifecycle = RepositoryEntities.repositoryLifecycle(loaded.entity);
-        const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(tenantOptions.tenantId, version, lifecycle));
-        await this.#commitProjectionOrCancel(loaded, entityId, state, version, lifecycle, deferred);
+        const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(tenantOptions.tenantId, version, lifecycle), this.#repository.metadata);
+        await this.#commitProjectionOrCancel(loaded, entityId, deferred);
         this.#notifyProjection(deferred);
         this.#publishProjectionChange(loaded, oldState, mode, state, lifecycle, version);
     }
@@ -1192,17 +1417,12 @@ class ProjectionEventExecution {
      *
      * @param loaded Loaded Projection and commit storage.
      * @param entityId Projection identifier.
-     * @param state Accepted Projection state.
-     * @param version Current Spine Version.
-     * @param lifecycle Accepted lifecycle flags.
      * @param deferred Deferred Stand update to cancel if storage rejects the commit.
      * @returns Completion after a successful storage commit.
      */
-    async #commitProjectionOrCancel(loaded, entityId, state, version, lifecycle, deferred) {
+    async #commitProjectionOrCancel(loaded, entityId, deferred) {
         try {
-            const outcome = await this.#commitProjectionRecord(loaded, entityId, state, version, lifecycle);
-            if (outcome !== "committed")
-                throw new Error("Concurrent Projection state commit conflict.");
+            await this.#commitProjectionRecord(loaded, entityId, deferred);
         }
         catch (error) {
             deferred.cancel();
@@ -1227,18 +1447,15 @@ class ProjectionEventExecution {
      *
      * @param loaded Loaded Projection and commit storage.
      * @param entityId Projection identifier.
-     * @param state Accepted Projection state.
-     * @param version Current Spine Version.
-     * @param lifecycle Accepted lifecycle flags.
-     * @returns The storage commit outcome.
+     * @param deferred Stand update containing the prepared record.
+     * @returns Completion after the storage commit.
      */
-    #commitProjectionRecord(loaded, entityId, state, version, lifecycle) {
-        const record = EntityRecords.pack(this.#repository.stateSchema, entityId, state, version, lifecycle);
+    #commitProjectionRecord(loaded, entityId, deferred) {
+        const record = RepositoryStand.preparedRecord(this.#repository, deferred, entityId);
         return loaded.commits.commit({
             context: loaded.storageInput.context,
             entity: loaded.storageInput,
             entityId,
-            ...(loaded.current === undefined ? {} : { expected: loaded.current }),
             next: record,
             ...(RepositoryStorage.historyConfiguration(this.#repository).stateHistory
                 ? { states: [record] }
@@ -1362,13 +1579,38 @@ const ProcessManagerQueries = Object.freeze({
         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);
+        const effectiveTenant = EffectiveTenants.current(runtime.context.multitenant, tenantId);
+        context.tenantId = effectiveTenant;
+        return processManagerQueryAccess.bind(entity, (plan, schema, query) => ProcessManagerQueries.read(runtime, effectiveTenant, plan, schema, query), context);
+    },
+    /**
+     * Routes a handler read to the registered state target before reaching storage.
+     *
+     * @typeParam Schema State schema supplied by the handler.
+     * @param runtime Current context services and local Stand.
+     * @param tenantId Effective tenant of the current operation.
+     * @param plan Compiled read criteria.
+     * @param schema State schema supplied by the handler.
+     * @param query Wire query carrying the actor and requested fields.
+     * @returns Detached state snapshots decoded with the caller's schema.
+     */
+    async read(runtime, tenantId, plan, schema, query) {
+        const routes = RegisteredTargets.forStand(runtime.stand);
+        const typeUrl = TypeUrls.derive(schema);
+        const target = routes?.find(typeUrl);
+        if (routes !== undefined && target === undefined)
+            throw new Error(`No bounded context registered query target "${typeUrl}".`);
+        if (target !== undefined && target.context.stand() !== runtime.stand) {
+            const visibility = target.repository.metadata.visibility;
+            if (visibility !== "query" && visibility !== "full")
+                throw new Error(`Query target "${typeUrl}" does not have query visibility.`);
+        }
+        const registeredSchema = target?.repository.stateSchema ?? schema;
+        if (target !== undefined)
+            routes?.validate(target, plan);
+        const destination = EffectiveTenants.destination(tenantId, target?.context.isMultitenant ?? runtime.context.multitenant);
+        const results = await QueryReader.read(target?.context.stand() ?? runtime.stand, registeredSchema, plan, destination, 10_000, query);
+        return Object.freeze(results.map((result) => clone(schema, result.state)));
     },
 });
 /**
@@ -1433,8 +1675,8 @@ class ProcessManagerExecutionSupport {
         const entityId = loaded.entity.id;
         const state = RepositoryEntities.repositoryState(loaded.entity);
         const lifecycle = RepositoryEntities.repositoryLifecycle(loaded.entity);
-        const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(options.tenantId, version, lifecycle));
-        await this.#storeProcessManagerRecord(loaded, entityId, state, version, lifecycle, events, deferred);
+        const deferred = await standAccess.deferUpdate(this.#runtime.stand, this.#repository.stateSchema, state, RepositoryStand.standUpdateOptions(options.tenantId, version, lifecycle), this.#repository.metadata);
+        await this.#storeProcessManagerRecord(loaded, entityId, events, deferred);
         this.#notifyProcessManager(deferred, events);
         return true;
     }
@@ -1456,19 +1698,13 @@ class ProcessManagerExecutionSupport {
      *
      * @param loaded Process Manager and commit storage.
      * @param entityId Process Manager identifier.
-     * @param state Accepted Process Manager state.
-     * @param version Current Spine Version.
-     * @param lifecycle Accepted lifecycle flags.
      * @param events Diagnostic Events to retain when configured.
      * @param deferred Stand update to notify or cancel.
      * @returns Completion after durable persistence.
      */
-    async #storeProcessManagerRecord(loaded, entityId, state, version, lifecycle, events, deferred) {
+    async #storeProcessManagerRecord(loaded, entityId, events, deferred) {
         try {
-            const outcome = await this.#commitProcessManagerRecord(loaded, entityId, state, version, lifecycle, events);
-            if (outcome !== "committed") {
-                throw new Error("Concurrent Process Manager state commit conflict.");
-            }
+            await this.#commitProcessManagerRecord(loaded, entityId, events, deferred);
             entityStateHistoryCaches.get(loaded.entity)?.clear();
         }
         catch (error) {
@@ -1481,20 +1717,17 @@ class ProcessManagerExecutionSupport {
      *
      * @param loaded Loaded Process Manager and commit storage.
      * @param entityId Process Manager identifier.
-     * @param state Accepted Process Manager state.
-     * @param version Current Spine Version.
-     * @param lifecycle Accepted lifecycle flags.
      * @param events Diagnostic Events to retain when configured.
-     * @returns The storage commit outcome.
+     * @param deferred Stand update containing the prepared record.
+     * @returns Completion after the storage commit.
      */
-    #commitProcessManagerRecord(loaded, entityId, state, version, lifecycle, events) {
+    #commitProcessManagerRecord(loaded, entityId, events, deferred) {
         const history = RepositoryStorage.historyConfiguration(this.#repository);
-        const record = EntityRecords.pack(this.#repository.stateSchema, entityId, state, version, lifecycle);
+        const record = RepositoryStand.preparedRecord(this.#repository, deferred, entityId);
         return loaded.commits.commit({
             context: loaded.storageInput.context,
             entity: loaded.storageInput,
             entityId,
-            ...(loaded.current === undefined ? {} : { expected: loaded.current }),
             next: record,
             ...(history.stateHistory ? { states: [record] } : {}),
             ...(history.processManagerEventHistory
@@ -1549,7 +1782,7 @@ class ProcessManagerCommandExecution {
      */
     async run(replayedRoute) {
         RepositorySignals.requireCommandId(this.#command);
-        const intake = this.#readIntake(replayedRoute);
+        const intake = await this.#readIntake(replayedRoute);
         if (intake === undefined)
             return undefined;
         const tenantOptions = RepositoryTenants.commandStandOptions(this.#runtime.context, this.#command);
@@ -1580,11 +1813,11 @@ class ProcessManagerCommandExecution {
      * @param replayedRoute Accepted inbox route, when present.
      * @returns Decoded Command, route, and assignee, or `undefined`.
      */
-    #readIntake(replayedRoute) {
+    async #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 route = replayedRoute ?? (await this.#repository.routeCommand(this.#command));
         const assignee = this.#routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
         return assignee === undefined ? undefined : Object.freeze({ assignee, message, route });
     }
@@ -2612,7 +2845,7 @@ const RepositorySignals = {
      * @returns New Event context with producer metadata.
      */
     eventContextWithProducer(context, repository, entityId, version) {
-        const producerId = EntityIds.pack(repository.stateSchema, entityId);
+        const producerId = EntityIds.packField(repository.idField.descriptor, entityId);
         return create(EventContextSchema, {
             ...context,
             producerId,
@@ -2953,7 +3186,7 @@ class EntityStateChangePublishing {
      * @returns Packed identifier.
      */
     #packEntityId(repository, entityId) {
-        return EntityIds.pack(repository.stateSchema, entityId);
+        return EntityIds.packField(repository.idField.descriptor, entityId);
     }
 }
 const EntityStateChangePublisher = Object.freeze(new EntityStateChangePublishing());
@@ -3079,7 +3312,7 @@ class HandlerDispatchPublishing {
      * @returns Packed identifier.
      */
     #packEntityId(repository, entityId) {
-        return EntityIds.pack(repository.stateSchema, entityId);
+        return EntityIds.packField(repository.idField.descriptor, entityId);
     }
     /**
      * Packs a subscriber or reactor dispatch diagnostic message.
@@ -3112,8 +3345,23 @@ const HandlerDispatchPublisher = Object.freeze(new HandlerDispatchPublishing());
 Object.freeze(RepositorySignals);
 /**
  * Internal repository stand operations.
+ * @internal
  */
-const RepositoryStand = {
+export const RepositoryStand = {
+    /**
+     * Returns the validated Stand snapshot with the authoritative routed ID.
+     *
+     * @param repository Supplies the state schema and validated ID descriptor.
+     * @param deferred Contains the prepared Stand record.
+     * @param entityId Authoritative routed Entity identifier.
+     * @returns An isolated prepared record with the authoritative packed ID.
+     */
+    preparedRecord(repository, deferred, entityId) {
+        const expectedId = EntityIds.packField(repository.idField.descriptor, entityId);
+        const record = clone(EntityRecordSchema, deferred.record);
+        record.entityId = expectedId;
+        return record;
+    },
     /**
      * Builds tenant, Version, and lifecycle options for a Stand update.
      *
@@ -3242,16 +3490,16 @@ const RepositoryTenants = {
      * @returns Tenant-aware storage context.
      */
     storageContextForCommand(context, command) {
-        if (!context.multitenant) {
-            return Object.freeze({ name: context.name, multitenant: false });
-        }
         const tenantId = RepositoryTenants.readCommandTenant(command);
-        if (tenantId === undefined)
+        if (context.multitenant && tenantId === undefined)
             throw new Error(`Multitenant command for "${context.name}" requires tenantId.`);
+        const effective = EffectiveTenants.current(context.multitenant, tenantId);
+        if (!context.multitenant)
+            return Object.freeze({ name: context.name, multitenant: false });
         return Object.freeze({
             name: context.name,
             multitenant: true,
-            tenantId: RepositoryTenants.require(tenantId),
+            tenantId: effective,
         });
     },
     /**
@@ -3262,16 +3510,16 @@ const RepositoryTenants = {
      * @returns Tenant-aware storage context.
      */
     storageContextForEvent(context, event) {
-        if (!context.multitenant) {
-            return Object.freeze({ name: context.name, multitenant: false });
-        }
         const tenantId = RepositoryTenants.readEventTenant(event);
-        if (tenantId === undefined)
+        if (context.multitenant && tenantId === undefined)
             throw new Error(`Multitenant event for "${context.name}" requires tenantId.`);
+        const effective = EffectiveTenants.current(context.multitenant, tenantId);
+        if (!context.multitenant)
+            return Object.freeze({ name: context.name, multitenant: false });
         return Object.freeze({
             name: context.name,
             multitenant: true,
-            tenantId: RepositoryTenants.require(tenantId),
+            tenantId: effective,
         });
     },
     /**
@@ -3282,14 +3530,15 @@ const RepositoryTenants = {
      * @returns Tenant-aware storage context.
      */
     storageContextForTenant(context, tenantId) {
+        if (context.multitenant && tenantId === undefined)
+            throw new Error(`Multitenant storage for "${context.name}" requires tenantId.`);
+        const effective = EffectiveTenants.current(context.multitenant, 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),
+            tenantId: effective,
         });
     },
     /**
@@ -3548,6 +3797,29 @@ Object.freeze(RepositoryHandlers);
  * Internal repository routes operations.
  */
 const RepositoryRoutes = {
+    /**
+     * Checks every class-aware route declaration against its receiving Entity.
+     *
+     * @param registered Entity constructor registered by the repository.
+     * @param routes Route declaration options selected for the repository.
+     */
+    requireRoutingEntities(registered, routes) {
+        RepositoryRoutes.requireRoutingEntity(registered, CommandRoutingInternals.entityType(routes.commandRouting), "Command");
+        RepositoryRoutes.requireRoutingEntity(registered, EventRoutingInternals.entityType(routes.eventRouting), "Event");
+        RepositoryRoutes.requireRoutingEntity(registered, StateUpdateRoutingInternals.entityType(routes.stateUpdateRouting), "State-update");
+    },
+    /**
+     * Rejects class-aware declarations for a different registered Entity constructor.
+     *
+     * @param registered Entity constructor registered by the repository.
+     * @param selected Constructor selected by class-aware declarations, if any.
+     * @param kind Command, Event, or state-update route kind for diagnostics.
+     */
+    requireRoutingEntity(registered, selected, kind) {
+        if (selected !== undefined && selected !== registered) {
+            throw new TypeError(`${kind} routing Entity class "${selected.name}" does not match "${registered.name}".`);
+        }
+    },
     /**
      * Builds immutable routing from an Entity constructor and its declarations.
      *
@@ -3816,7 +4088,7 @@ const RepositoryRoutes = {
      * @returns Function that routes one Command.
      */
     commandSelector(schemas, readiness, routes, idField) {
-        return (command) => RepositoryRoutes.routeCommand(command, readiness.command, schemas.command, idField, routes.command);
+        return (command, reads) => RepositoryRoutes.routeCommand(command, readiness.command, schemas.command, idField, routes.command, reads);
     },
     /**
      * Builds an Event route function from readiness and custom declarations.
@@ -3830,7 +4102,7 @@ const RepositoryRoutes = {
      * @returns Function that routes one Event.
      */
     eventSelector(schemas, readiness, filters, routes, idField) {
-        return (event) => RepositoryRoutes.routeEvent(event, readiness.event, filters.commandReactionMap, schemas.event, idField, routes.event);
+        return (event, reads) => RepositoryRoutes.routeEvent(event, readiness.event, filters.commandReactionMap, schemas.event, idField, routes.event, reads);
     },
     /**
      * Builds a state-update route function for Projection subscriptions.
@@ -3843,7 +4115,7 @@ const RepositoryRoutes = {
      * @returns Function that routes one state-change Event.
      */
     stateSelector(schemas, subscriptions, routes, idField) {
-        return (event) => RepositoryRoutes.routeStateUpdate(event, schemas.state, subscriptions, idField, routes.state);
+        return (event, reads) => RepositoryRoutes.routeStateUpdate(event, schemas.state, subscriptions, idField, routes.state, reads);
     },
     /**
      * Routes a Command to its registered assignee and target Entity ID.
@@ -3854,9 +4126,10 @@ const RepositoryRoutes = {
      * @param schemas Accepted Command schemas.
      * @param targetIdField Canonical target Entity ID field.
      * @param commandRoutes Custom Command routes by schema.
+     * @param reads Query access for this routing invocation.
      * @returns Deferred Command route for one target.
      */
-    routeCommand(command, readiness, schemas, targetIdField, commandRoutes) {
+    async routeCommand(command, readiness, schemas, targetIdField, commandRoutes, reads) {
         const message = command.message;
         if (message === undefined || message.typeUrl === "") {
             throw new Error("Repository command routing requires command.message.typeUrl.");
@@ -3866,10 +4139,10 @@ const RepositoryRoutes = {
         if (assignee === undefined) {
             throw new Error(`Repository command routing has no assignee for "${schema.typeName}".`);
         }
-        const customRoute = commandRoutes.get(schema);
-        const candidateId = customRoute === undefined
+        const route = commandRoutes.get(schema);
+        const candidateId = route === undefined
             ? RepositoryRoutes.readFirstFieldId(message, schema, "command")
-            : RepositoryRoutes.callCommandRoute(customRoute, message, schema, command.context);
+            : await RepositoryRoutes.callCommandRoute(route, message, schema, command.context, reads);
         return Object.freeze({
             entityId: RepositoryRoutes.readRouteId(candidateId, targetIdField, "command"),
             messageFullTypeName: schema.typeName,
@@ -3902,14 +4175,15 @@ const RepositoryRoutes = {
      * @param message Packed Command payload.
      * @param schema Registered Command schema.
      * @param context Source Command context, when present.
+     * @param reads Query access for this routing invocation.
      * @returns Candidate target Entity ID.
      */
-    callCommandRoute(route, message, schema, context) {
+    async callCommandRoute(route, message, schema, context, reads) {
         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));
+        return await route(unpacked, context ?? create(CommandContextSchema), reads);
     },
     /**
      * Routes an Event to interested Entity IDs using custom or default routing.
@@ -3921,19 +4195,20 @@ const RepositoryRoutes = {
      * @param schemas Accepted Event schemas.
      * @param targetIdField Canonical target Entity ID field.
      * @param eventRoutes Custom Event routes by schema.
+     * @param reads Query access for this routing invocation.
      * @returns Deferred Event route with target IDs.
      */
-    routeEvent(event, readiness, commandReactions, schemas, targetIdField, eventRoutes) {
+    async routeEvent(event, readiness, commandReactions, schemas, targetIdField, eventRoutes, reads) {
         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");
         if (!RepositoryRoutes.hasEventReceiver(schema.typeName, commandReactions, readiness))
             throw new Error(`Repository event routing has no receiver for "${schema.typeName}".`);
-        const customRoute = eventRoutes.get(schema);
-        const entityIds = customRoute === undefined
+        const route = eventRoutes.get(schema);
+        const entityIds = route === undefined
             ? [RepositoryRoutes.readEventEntityId(event, message, schema, targetIdField)]
-            : RepositoryRoutes.callEventRoute(customRoute, message, schema, event.context, targetIdField);
+            : await RepositoryRoutes.callEventRoute(route, message, schema, event.context, targetIdField, reads);
         return Object.freeze({
             entityIds: Object.freeze([...entityIds]),
             messageFullTypeName: schema.typeName,
@@ -4022,19 +4297,21 @@ const RepositoryRoutes = {
      * @param subscriptions State subscribers by source type.
      * @param targetIdField Canonical Projection ID field.
      * @param routes Custom state-update routes by schema.
+     * @param reads Query access for this routing invocation.
      * @returns Route and decoded state, or `undefined` when uninterested.
      */
-    routeStateUpdate(event, schemas, subscriptions, targetIdField, routes) {
-        const update = RepositoryRoutes.decodeStateUpdate(event, schemas, "Repository state-update routing");
+    async routeStateUpdate(event, schemas, subscriptions, targetIdField, routes, reads) {
+        const operation = "Repository state-update routing";
+        const update = RepositoryRoutes.decodeStateUpdate(event, schemas, operation);
         const candidates = subscriptions.get(update?.schema.typeName ?? "") ?? [];
         const interested = RepositoryRoutes.originSubscribers(candidates, event);
         if (update === undefined || interested.length === 0)
             return undefined;
         const { schema, state } = update;
-        const custom = routes.get(schema);
-        const candidateIds = custom === undefined
+        const route = routes.get(schema);
+        const candidateIds = route === undefined
             ? [RepositoryRoutes.firstCompatibleId(state, schema, targetIdField, "state update")]
-            : RepositoryRoutes.callStateUpdateRoute(custom, state, event.context, targetIdField);
+            : await RepositoryRoutes.callStateUpdateRoute(route, state, event.context, targetIdField, reads);
         return Object.freeze({
             entityIds: Object.freeze([...candidateIds]),
             messageFullTypeName: schema.typeName,
@@ -4087,14 +4364,13 @@ const RepositoryRoutes = {
      * @param state Decoded source Entity state.
      * @param context Source Event context, when present.
      * @param targetIdField Canonical Projection ID field.
+     * @param reads Query access for this routing invocation.
      * @returns Validated Projection target IDs.
      */
-    callStateUpdateRoute(route, state, context, targetIdField) {
-        const candidates = route(state, context ?? create(EventContextSchema));
+    async callStateUpdateRoute(route, state, context, targetIdField, reads) {
+        const candidates = await route(state, context ?? create(EventContextSchema), reads);
         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");
@@ -4102,7 +4378,8 @@ const RepositoryRoutes = {
             if (!unique.has(key))
                 unique.set(key, structuredClone(id));
         }
-        return Object.freeze([...unique.values()]);
+        const recipients = Object.freeze([...unique.values()]);
+        return recipients;
     },
     /**
      * Calls a custom Event route and validates its target IDs.
@@ -4113,20 +4390,18 @@ const RepositoryRoutes = {
      * @param schema Registered Event schema.
      * @param context Source Event context, when present.
      * @param targetIdField Canonical target Entity ID field.
+     * @param reads Query access for this routing invocation.
      * @returns Validated target Entity IDs.
      */
-    callEventRoute(route, message, schema, context, targetIdField) {
+    async callEventRoute(route, message, schema, context, targetIdField, reads) {
         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));
+        const candidates = await route(unpacked, context ?? create(EventContextSchema), reads);
         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");
@@ -4134,7 +4409,20 @@ const RepositoryRoutes = {
             if (!unique.has(key))
                 unique.set(key, structuredClone(id));
         }
-        return Object.freeze([...unique.values()]);
+        const recipients = Object.freeze([...unique.values()]);
+        return recipients;
+    },
+    /**
+     * Records a warning for a large final route without changing its recipients.
+     *
+     * @param signal Signal type selected by the route.
+     * @param repository Receiving repository state type.
+     * @param count Distinct validated recipient count.
+     */
+    warnLargeRoute(signal, repository, count) {
+        if (count <= 1_000)
+            return;
+        emitServerWarning(serverEnvironmentAccess.loggerFor(ServerEnvironment.instance()), `Routing ${signal} to ${String(count)} recipients in repository ${repository}.`, { operation: "repository.route", count, entityType: repository });
     },
     /**
      * Finds a registered message schema by its type URL.
@@ -4405,6 +4693,21 @@ Object.freeze(RepositoryRoutes);
  * Internal repository storage operations.
  */
 const RepositoryStorage = {
+    /**
+     * Opens provider Entity storage for one read scope without a commit handle.
+     *
+     * @typeParam I Entity identifier type.
+     * @typeParam S Generated Entity state type.
+     * @param factory Provider storage factory.
+     * @param input Entity storage location and schema.
+     * @returns The independently closeable Entity storage ports.
+     */
+    openReadEntityStorage(factory, input) {
+        const candidate = factory;
+        if (candidate.createEntityStorage === undefined)
+            throw new Error("StorageFactory does not provide Entity storage for repository reads.");
+        return candidate.createEntityStorage(input);
+    },
     /**
      * Opens Entity storage and an atomic commit port from a storage factory.
      *
@@ -4441,9 +4744,9 @@ const RepositoryStorage = {
      * @returns Shared Entity storage handle.
      */
     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);
+        const handle = RepositoryStorage.openEntityStorage(factory, input);
         if (handles === undefined) {
             handles = new Map();
             repositoryEntityHandles.set(repository, handles);
@@ -4464,7 +4767,7 @@ const RepositoryStorage = {
      * @returns Entity storage description for the provider.
      */
     entityStorageInput(repository, context) {
-        const descriptor = entityStorageDescriptor(context, SpecScanner.scan(repository.entityType));
+        const descriptor = entityStorageDescriptor(context, repositorySpecScanner.scan(repository.entityType, repository.metadata), repository.metadata);
         const history = RepositoryStorage.historyConfiguration(repository);
         return {
             ...descriptor,
@@ -5483,7 +5786,7 @@ const InboxHandoff = {
      * @returns Completion of Inbox receipt and its selected delivery operation.
      */
     async handoffEntityCommand(repository, runtime, command) {
-        const route = repository.routeCommand(command);
+        const route = await repository.routeCommand(command);
         const commandId = RepositorySignals.requireCommandId(command);
         const whenReceived = new Date();
         const keepUntil = new Date(whenReceived.getTime() + inboxDedupMs);
@@ -5576,8 +5879,12 @@ const InboxHandoff = {
             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);
+        for (let start = 0; start < entityIds.length; start += 1_000) {
+            const inputs = entityIds
+                .slice(start, start + 1_000)
+                .map((entityId) => InboxHandoff.pmEventInboxInput(repository, eventId.value, event, entityId, keepUntil));
+            await runtime.entityInbox.receiveAll(delivery, inputs, deliveryTenantId);
+        }
     },
     /**
      * Builds a pending Process Manager Event delivery for a single target.
@@ -5653,9 +5960,8 @@ const RepositoryDispatch = {
         const dispatcher = Object.freeze({
             messageSchemas: () => routing.eventSchemas,
             externalEventSchemas: () => routing.externalEventSchemas,
-            accept: (event) => {
-                accepted.set(event, repository.routeEvent(event));
-                return Promise.resolve();
+            accept: async (event) => {
+                accepted.set(event, await repository.routeEvent(event));
             },
             dispatch: (event) => {
                 const route = accepted.get(event);
@@ -5681,9 +5987,8 @@ const RepositoryDispatch = {
         const dispatcher = Object.freeze({
             messageSchemas: () => Object.freeze([schema]),
             externalEventSchemas: () => (hasOrigin("external") ? [schema] : []),
-            accept: (event) => {
-                accepted.set(event, routing.routeStateUpdate(event) ?? null);
-                return Promise.resolve();
+            accept: async (event) => {
+                accepted.set(event, (await repositoryAccess.routeStateUpdate(repository, event)) ?? null);
             },
             dispatch: (event) => RepositoryDispatch.dispatchAcceptedState(repository, routing, event, accepted),
         });
@@ -5758,8 +6063,7 @@ const RepositoryDispatch = {
         return (event, rebuild) => {
             const runtime = repositoryRuntimes.get(repository);
             if (runtime === undefined) {
-                void repository.routeEvent(event);
-                return Promise.resolve();
+                return repository.routeEvent(event).then(() => undefined);
             }
             return new ProjectionEventExecution(repository, routing, runtime, event, rebuild).runDirect();
         };
@@ -5777,10 +6081,10 @@ const RepositoryDispatch = {
         const runtime = repositoryRuntimes.get(repository);
         if (runtime === undefined) {
             if (acceptedRoute === undefined)
-                void repository.routeEvent(event);
+                await repository.routeEvent(event);
             return;
         }
-        const route = acceptedRoute ?? repository.routeEvent(event);
+        const route = acceptedRoute ?? (await repository.routeEvent(event));
         switch (repository.entityFamily) {
             case "aggregate":
                 await RepositoryDispatch.dispatchAggregateEvent(repository, routing, runtime, event, route);
@@ -5822,10 +6126,10 @@ const RepositoryDispatch = {
         const runtime = repositoryRuntimes.get(repository);
         if (runtime === undefined) {
             if (acceptedRoute === undefined)
-                void routing.routeStateUpdate(event);
+                await repositoryAccess.routeStateUpdate(repository, event);
             return;
         }
-        const route = acceptedRoute ?? routing.routeStateUpdate(event);
+        const route = acceptedRoute ?? (await repositoryAccess.routeStateUpdate(repository, event));
         if (route === undefined)
             return;
         for (const entityId of route.entityIds) {
@@ -5843,7 +6147,7 @@ const RepositoryDispatch = {
     async dispatchRepositoryCommand(repository, routing, command) {
         const runtime = repositoryRuntimes.get(repository);
         if (runtime === undefined) {
-            void repository.routeCommand(command);
+            await repository.routeCommand(command);
             return;
         }
         if (repository.entityFamily === "aggregate") {
@@ -5854,7 +6158,7 @@ const RepositoryDispatch = {
             await InboxHandoff.handoffEntityCommand(repository, runtime, command);
             return;
         }
-        void repository.routeCommand(command);
+        await repository.routeCommand(command);
     },
 };
 Object.freeze(RepositoryDispatch);