@spine-event-engine/server 2.0.0-snapshot.26 → 2.0.0-snapshot.28

package/dist/repository/repository.js

@@ -36,7 +36,7 @@ import { snapshotTrustedReader, } from "@spine-event-engine/core/spi/trusted-rea
 import { Code, ConnectError } from "@connectrpc/connect";
 import { EventDispatcherOriginSchemas } from "../bus/event-dispatcher-origin-schemas.js";
 import { receptionObservation } from "../delivery/reception-observation.js";
-import { commitFenced, withDeliveryCommitFence } from "./commit-fence.js";
+import { commitFenced, withDeliveryCommitFence, withoutDeliveryCommitFence, } from "./commit-fence.js";
 import { AgentHistoryReads, } from "../agent/agent-history.js";
 import { AgentLiveAiRuntime } from "../agent/agent-live-ai-runtime.js";
 import { AgentLiveAudit } from "../agent/agent-live-audit.js";
@@ -690,19 +690,19 @@ export const repositoryAccess = Object.freeze({
         });
     },
     /**
-     * Looks up the Aggregate or Process Manager inbox replay target.
+     * Looks up the Aggregate or Process Manager Inbox delivery target.
      *
      * @param repository Repository to inspect.
-     * @returns Its replay target, when registered.
+     * @returns Its delivery target, when registered.
      */
     entityInboxTarget(repository) {
         return repositoryEntityInboxTargets.get(repository);
     },
     /**
-     * Looks up the Projection inbox replay target.
+     * Looks up the Projection Inbox delivery target.
      *
      * @param repository Repository to inspect.
-     * @returns Its replay target, when registered.
+     * @returns Its delivery target, when registered.
      */
     projectionInboxTarget(repository) {
         return repositoryProjectionInboxTargets.get(repository);
@@ -1067,7 +1067,8 @@ class AggregateExecutionSupport {
         return Object.freeze([produced]);
     }
     /**
-     * Stores Aggregate state and diagnostic and delivery Events in one atomic commit.
+     * Writes Aggregate state, diagnostic history, and produced Events through the configured
+     * commit storage. Atomicity depends on that storage implementation.
      *
      * @param loaded Aggregate and commit storage to update.
      * @param entityId Aggregate identifier.
@@ -1141,7 +1142,7 @@ class AggregateExecutionSupport {
         await loaded.events.append(clone(EventSchema, event));
     }
     /**
-     * Completes persistence before scheduling best-effort stored-Event dispatch.
+     * Completes persistence and one handoff attempt for each produced Event.
      *
      * @param loaded Aggregate and commit storage to update.
      * @param entityId Aggregate identifier.
@@ -1149,14 +1150,14 @@ class AggregateExecutionSupport {
      * @param dispatch Publishes one committed Event.
      * @param onPersisted Runs after durable persistence.
      * @param diagnostics Events to retain in diagnostic history with this commit.
-     * @returns A deferred follow-up that dispatches the Events.
+     * @returns Completion after the Event handoff attempts settle.
      */
     async persistAggregateAndDispatch(loaded, entityId, events, dispatch, onPersisted, diagnostics = events) {
         const committed = await this.persistAggregateUpdate(loaded, entityId, events, diagnostics);
         if (!committed)
-            return () => Promise.resolve();
+            return;
         await onPersisted();
-        return async () => {
+        await withoutDeliveryCommitFence(async () => {
             await Promise.all(events.map(async (event) => {
                 try {
                     await dispatch(event);
@@ -1165,7 +1166,7 @@ class AggregateExecutionSupport {
                     this.#runtime.publisher.reportFailure("event", event, error);
                 }
             }));
-        };
+        });
     }
     /**
      * Restores an Aggregate or creates one with initial state and version zero.
@@ -1225,27 +1226,27 @@ class AggregateCommandExecution {
     /**
      * Validates the Command and executes its assignee when registered.
      *
-     * @param replayedRoute Accepted route from durable inbox replay, when present.
-     * @returns A deferred dispatch follow-up, or `undefined` without an assignee.
+     * @param deliveredRoute Accepted route from durable inbox delivery, when present.
+     * @returns Completion after processing and outgoing handoff attempts.
      */
-    async run(replayedRoute) {
+    async run(deliveredRoute) {
         void RepositorySignals.requireCommandId(this.#command);
-        const intake = await this.#readIntake(replayedRoute);
+        const intake = await this.#readIntake(deliveredRoute);
         if (intake === undefined)
             return undefined;
-        return this.#runAssignee(intake);
+        await this.#runAssignee(intake);
     }
     /**
      * Decodes the Command and selects its registered assignee.
      *
-     * @param replayedRoute Accepted inbox route, when present.
+     * @param deliveredRoute Accepted inbox route, when present.
      * @returns Decoded message and route with an assignee, or `undefined`.
      */
-    async #readIntake(replayedRoute) {
+    async #readIntake(deliveredRoute) {
         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 ?? (await this.#repository.routeCommand(this.#command));
+        const route = deliveredRoute ?? (await this.#repository.routeCommand(this.#command));
         const assignee = this.#routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
         return assignee === undefined ? undefined : Object.freeze({ message, route, assignee });
     }
@@ -1253,7 +1254,7 @@ class AggregateCommandExecution {
      * Invokes the assignee, persists its Events, or publishes a declared rejection.
      *
      * @param intake Decoded Command, target route, and assignee.
-     * @returns A deferred Event follow-up or a rejection follow-up.
+     * @returns Completion after processing and outgoing handoff attempts.
      */
     async #runAssignee(intake) {
         const loaded = await this.#support.loadAggregate(intake.route.entityId);
@@ -1263,23 +1264,24 @@ class AggregateCommandExecution {
             produced = await this.#invokeAssignee(loaded.entity, intake.assignee.handler, intake.message, EntityInvocation.commandHandlerContext(this.#command), this.#command.context?.actorContext);
         }
         catch (error) {
-            return this.#postAssigneeRejection(intake, error);
+            await this.#postAssigneeRejection(intake, error);
+            return undefined;
         }
         const events = this.#bindProducedEvents(this.#support.normalizeProducedSignals(produced), intake.route.entityId, RepositoryEntities.priorVersion(loaded.current));
-        return this.#persistAssigneeResult(loaded, intake.route.entityId, events);
+        await this.#persistAssigneeResult(loaded, intake.route.entityId, events);
     }
     /**
      * Publishes a declared rejection from the invoked Aggregate assignee.
      *
      * @param intake Assignee and target route for the rejected Command.
      * @param error Handler failure to classify and publish.
-     * @returns A rejection follow-up when one is created.
+     * @returns Completion after the rejection Event handoff attempt.
      */
-    #postAssigneeRejection(intake, error) {
+    async #postAssigneeRejection(intake, 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);
+        await RepositorySignals.postRejectionEvent(this.#runtime, this.#repository, this.#command, intake.route.entityId, error);
     }
     /**
      * Publishes a best-effort Command dispatch diagnostic.
@@ -1295,11 +1297,11 @@ class AggregateCommandExecution {
      * @param loaded Aggregate and commit storage.
      * @param entityId Target Aggregate identifier.
      * @param events Bound Events from the assignee.
-     * @returns A deferred committed-Event dispatch follow-up.
+     * @returns Completion after committed Event handoff attempts.
      */
-    #persistAssigneeResult(loaded, entityId, events) {
+    async #persistAssigneeResult(loaded, entityId, events) {
         const committedVersion = loaded.version + 1n;
-        return this.#support.persistAggregateAndDispatch(loaded, entityId, events, (event) => this.#runtime.publisher.publishCommittedEvent(event), () => {
+        await this.#support.persistAggregateAndDispatch(loaded, entityId, 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
@@ -1489,10 +1491,9 @@ class AggregateEventExecution {
             await this.#support.appendDiagnosticEvent(loaded, entityId, source);
             return;
         }
-        const dispatch = await this.#support.persistAggregateAndDispatch(loaded, entityId, produced, (event) => this.#runtime.publisher.publishReactorEvent(event), () => {
+        await this.#support.persistAggregateAndDispatch(loaded, entityId, produced, (event) => this.#runtime.publisher.publishReactorEvent(event), () => {
             this.#publishStateChange(loaded, entityId);
         }, [source, ...produced]);
-        void dispatch();
     }
     /**
      * Publishes an Entity state-change System Event when the Aggregate changed.
@@ -1675,7 +1676,7 @@ class ProjectionEventExecution {
      * Delivers an accepted Event for one Projection target.
      *
      * @param entityId Target Projection identifier.
-     * @param acceptedRoute Route accepted before replay.
+     * @param acceptedRoute Route accepted before deliver.
      * @returns Completion after target delivery.
      */
     async runTarget(entityId, acceptedRoute) {
@@ -2911,27 +2912,29 @@ class ProcessManagerCommandExecution {
     /**
      * Invokes the registered Command handler and commits its results.
      *
-     * @param replayedRoute Accepted route from durable inbox replay, when present.
-     * @returns A deferred Command follow-up, rejection follow-up, or `undefined`.
+     * @param deliveredRoute Accepted route from durable inbox delivery, when present.
+     * @returns Completion after processing and outgoing handoff attempts.
      */
-    async run(replayedRoute) {
+    async run(deliveredRoute) {
         RepositorySignals.requireCommandId(this.#command);
-        const intake = await this.#readIntake(replayedRoute);
+        const intake = await this.#readIntake(deliveredRoute);
         if (intake === undefined)
             return undefined;
         const tenantOptions = RepositoryTenants.commandStandOptions(this.#runtime.context, this.#command);
         const loaded = await this.#support.load(intake.route.entityId, tenantOptions);
         await this.#publishDispatch(loaded, intake.route.entityId);
+        let produced;
         try {
-            const produced = await this.#invoke(loaded.entity, intake.assignee, intake.message, tenantOptions.tenantId);
-            return await this.#commitAndPublish(loaded, tenantOptions, intake, produced);
+            produced = await this.#invoke(loaded.entity, intake.assignee, intake.message, tenantOptions.tenantId);
         }
         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);
+            await RepositorySignals.postRejectionEvent(this.#runtime, this.#repository, this.#command, intake.route.entityId, error);
+            return undefined;
         }
+        await this.#commitAndPublish(loaded, tenantOptions, intake, produced);
     }
     /**
      * Persists required Agent dispatch history before the handler runs.
@@ -2961,14 +2964,14 @@ class ProcessManagerCommandExecution {
     /**
      * Decodes a registered Command and finds its assignee.
      *
-     * @param replayedRoute Accepted inbox route, when present.
+     * @param deliveredRoute Accepted inbox route, when present.
      * @returns Decoded Command, route, and assignee, or `undefined`.
      */
-    async #readIntake(replayedRoute) {
+    async #readIntake(deliveredRoute) {
         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 ?? (await this.#repository.routeCommand(this.#command));
+        const route = deliveredRoute ?? (await this.#repository.routeCommand(this.#command));
         const assignee = this.#routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
         return assignee === undefined ? undefined : Object.freeze({ assignee, message, route });
     }
@@ -2979,7 +2982,7 @@ class ProcessManagerCommandExecution {
      * @param tenantOptions Stand tenant selection.
      * @param intake Assignee and target route.
      * @param producedSignals Validated handler results.
-     * @returns Deferred Command publication when Commands were produced.
+     * @returns Completion after produced-signal handoff attempts.
      */
     async #commitAndPublish(loaded, tenantOptions, intake, producedSignals) {
         const commands = this.#commandOutputs(intake.assignee, producedSignals);
@@ -2988,12 +2991,10 @@ class ProcessManagerCommandExecution {
         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);
-            };
+        await withoutDeliveryCommitFence(async () => {
+            await this.#postEvents(events);
+            await this.#postCommands(commands, this.#command);
+        });
     }
     /**
      * Binds substitution results as Commands and requires nonempty output.
@@ -3156,15 +3157,15 @@ class ProcessManagerCommandExecution {
         }
     }
     /**
-     * Schedules publication of produced Events.
+     * Publishes the Process Manager Command's produced Events after its commit.
      *
      * @param events Bound Events to publish.
+     * @returns Completion after each Event handoff attempt.
      */
-    #postEvents(events) {
-        for (const event of events) {
-            // spine-log-boundary: server.repository_event_follow_up
-            void this.#runtime.publisher.publishReactorEvent(event);
-        }
+    async #postEvents(events) {
+        await Promise.all(events.map((event) => {
+            return this.#runtime.publisher.publishReactorEvent(event);
+        }));
     }
 }
 /**
@@ -3204,16 +3205,16 @@ class ProcessManagerEventExecution {
         }
         this.#validateSourceEventIdForFollowUps(intake);
         if (intake.route.entityIds.length === 1) {
-            await InboxHandoff.handoffPmEvent(this.#repository, this.#runtime, this.#event, intake.route.entityIds[0]);
+            await InboxHandoff.handoffEntityEvent(this.#repository, this.#runtime, this.#event, intake.route.entityIds[0]);
             return;
         }
-        await InboxHandoff.handoffPmEvents(this.#repository, this.#runtime, this.#event, intake.route.entityIds);
+        await InboxHandoff.handoffEntityEvents(this.#repository, this.#runtime, this.#event, intake.route.entityIds);
     }
     /**
      * Delivers a routed Event for one target under the duplicate-dispatch guard.
      *
      * @param entityId Target Entity identifier.
-     * @param acceptedRoute Route accepted before replay.
+     * @param acceptedRoute Route accepted before deliver.
      * @returns Completion after guarded target execution.
      */
     async runTarget(entityId, acceptedRoute) {
@@ -3267,8 +3268,10 @@ class ProcessManagerEventExecution {
         if (!committed)
             return;
         this.#publishChangedState(loaded, entityId);
-        this.#postEvents(events);
-        this.#postCommands(commands);
+        await withoutDeliveryCommitFence(async () => {
+            await this.#postEvents(events);
+            await this.#postCommands(commands);
+        });
     }
     /**
      * Publishes a state-change System Event when the Entity changed.
@@ -3446,23 +3449,24 @@ class ProcessManagerEventExecution {
      * Publishes each produced Command in handler order.
      *
      * @param commands Bound Commands to publish.
+     * @returns Completion after each Command handoff attempt.
      */
-    #postCommands(commands) {
+    async #postCommands(commands) {
         for (const command of commands) {
             // spine-log-boundary: server.process_manager_command_follow_up
-            void this.#runtime.publisher.publishCommand(command);
+            await this.#runtime.publisher.publishCommand(command);
         }
     }
     /**
-     * Schedules publication of produced Events.
+     * Publishes the Process Manager Event's produced Events after its commit.
      *
      * @param events Bound Events to publish.
+     * @returns Completion after each Event handoff attempt.
      */
-    #postEvents(events) {
-        for (const event of events) {
-            // spine-log-boundary: server.process_manager_event_follow_up
-            void this.#runtime.publisher.publishReactorEvent(event);
-        }
+    async #postEvents(events) {
+        await Promise.all(events.map((event) => {
+            return this.#runtime.publisher.publishReactorEvent(event);
+        }));
     }
 }
 /**
@@ -4132,18 +4136,18 @@ const RepositorySignals = {
         });
     },
     /**
-     * Builds a rejection Event and returns a best-effort publication follow-up.
+     * Builds a rejection Event and awaits one publication attempt.
      *
      * @param runtime Context signal and publication services.
      * @param repository Repository of the rejected Command.
      * @param command Command rejected by its handler.
      * @param entityId Target Entity identifier.
      * @param rejection Declared handler rejection.
-     * @returns Deferred rejection Event publication.
+     * @returns Completion after the rejection handoff attempt settles.
      */
-    postRejectionEvent(runtime, repository, command, entityId, rejection) {
+    async postRejectionEvent(runtime, repository, command, entityId, rejection) {
         const event = this.rejectionEvent(runtime, repository, command, entityId, rejection);
-        return async () => {
+        await withoutDeliveryCommitFence(async () => {
             try {
                 // spine-log-boundary: server.repository_rejection_follow_up
                 await runtime.publisher.publishRejectionEvent(event);
@@ -4151,7 +4155,7 @@ const RepositorySignals = {
             catch (error) {
                 runtime.publisher.reportFailure("event", event, error);
             }
-        };
+        });
     },
     /**
      * Creates the original declared rejection envelope without publishing it.
@@ -4738,13 +4742,13 @@ const RepositoryTenants = {
         return RepositoryTenants.require(tenantId);
     },
     /**
-     * Validates an Event tenant before Process Manager inbox handoff.
+     * Validates an Event tenant before Entity Inbox handoff.
      *
      * @param context Bounded context storage mode.
-     * @param event Event entering Process Manager delivery.
+     * @param event Event entering Entity Inbox delivery.
      * @returns Validated tenant, or `undefined` for single-tenant contexts.
      */
-    requirePmEventTenant(context, event) {
+    requireEntityEventTenant(context, event) {
         if (!context.multitenant) {
             return undefined;
         }
@@ -7254,7 +7258,7 @@ const InboxMessages = {
             }
         }
         if (entityId === undefined) {
-            throw new Error("Entity Inbox replay stored target ID is incompatible with the repository.");
+            throw new Error("Entity Inbox delivery stored target ID is incompatible with the repository.");
         }
         return RepositoryRoutes.readRouteId(entityId, idField, "command");
     },
@@ -7266,7 +7270,7 @@ const InboxMessages = {
      */
     readInboxCommand(message) {
         if (message.label !== "HANDLE_COMMAND") {
-            throw new Error(`Entity Inbox replay does not handle "${message.label}" messages.`);
+            throw new Error(`Entity Inbox delivery does not handle "${message.label}" messages.`);
         }
         const command = message.signal === undefined ? undefined : AnyPacker.tryUnpack(message.signal, CommandSchema);
         if (command === undefined) {
@@ -7275,13 +7279,13 @@ const InboxMessages = {
         return command;
     },
     /**
-     * Reads an Event labeled for a Process Manager reaction.
+     * Reads an Event labeled for an Entity reaction.
      *
      * @param message Stored Inbox message to validate and unpack.
      * @returns The stored Event envelope.
      */
-    readPmInboxEvent(message) {
-        return InboxMessages.readStoredEvent(message, "REACT_UPON_EVENT", "Entity Inbox replay", "Entity Inbox replay requires a readable stored event.");
+    readEntityInboxEvent(message) {
+        return InboxMessages.readStoredEvent(message, "REACT_UPON_EVENT", "Entity Inbox delivery", "Entity Inbox delivery requires a readable stored event.");
     },
     /**
      * Reads an Event labeled for a Projection update.
@@ -7290,20 +7294,20 @@ const InboxMessages = {
      * @returns The stored Event envelope.
      */
     readProjectionInboxEvent(message) {
-        return InboxMessages.readStoredEvent(message, "UPDATE_SUBSCRIBER", "Projection inbox replay", "Projection inbox replay requires a readable stored event.");
+        return InboxMessages.readStoredEvent(message, "UPDATE_SUBSCRIBER", "Projection inbox delivery", "Projection inbox delivery requires a readable stored event.");
     },
     /**
      * Validates an Inbox operation label and decodes its stored Event bytes.
      *
      * @param message Stored Inbox message to inspect.
      * @param expectedLabel Operation label required by the caller.
-     * @param replayName Human-readable operation name used in label errors.
+     * @param deliverName Human-readable operation name used in label errors.
      * @param unreadableMessage Error text used when Event decoding fails.
      * @returns The stored Event envelope.
      */
-    readStoredEvent(message, expectedLabel, replayName, unreadableMessage) {
+    readStoredEvent(message, expectedLabel, deliverName, unreadableMessage) {
         if (message.label !== expectedLabel) {
-            throw new Error(`${replayName} does not handle "${message.label}" messages.`);
+            throw new Error(`${deliverName} does not handle "${message.label}" messages.`);
         }
         const signal = message.signal === undefined
             ? undefined
@@ -7322,7 +7326,7 @@ Object.freeze(InboxMessages);
 /**
  * Validates and dispatches stored Inbox signals to their recorded Entity targets.
  */
-const InboxReplay = {
+const InboxDelivery = {
     /**
      * Dispatches a stored Aggregate Command after checking its tenant and payload.
      *
@@ -7330,44 +7334,66 @@ const InboxReplay = {
      * @param routing Registered handlers and message schemas.
      * @param message Stored Inbox message with the recorded target.
      * @param deliveryTenantId Tenant selected by delivery in a multitenant context.
-     * @returns Any follow-up work that must wait for Inbox completion.
+     * @returns Completion after processing and outgoing handoff attempts.
      */
-    async replayAggregateCommand(repository, routing, message, deliveryTenantId) {
+    async deliverAggregateCommand(repository, routing, message, deliveryTenantId) {
         const runtime = repositoryRuntimes.get(repository);
         if (runtime === undefined) {
-            throw new Error("Aggregate inbox replay requires a bound repository runtime.");
+            throw new Error("Aggregate inbox delivery requires a bound repository runtime.");
         }
         if (message.label !== "HANDLE_COMMAND") {
-            throw new Error(`Aggregate inbox replay does not handle "${message.label}" messages.`);
+            throw new Error(`Aggregate inbox delivery 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);
+        InboxDelivery.validateDeliveryTenant(runtime.context, deliveryTenantId, command);
+        InboxDelivery.validateDeliveredCommandPayload(routing, command);
+        const route = InboxDelivery.deliverCommandRoute(repository, routing, message, command);
+        await new AggregateCommandExecution(repository, routing, runtime, command).run(route);
     },
     /**
-     * Routes Process Manager Command or Event replay by its stored operation label.
+     * Delivers a stored Event to the recorded Aggregate target.
+     *
+     * @param repository Aggregate repository receiving the Event.
+     * @param routing Registered Event handlers and message schemas.
+     * @param message Stored Inbox row with the recorded target.
+     * @param deliveryTenantId Tenant selected by delivery in a multitenant context.
+     * @returns Completion after the guarded reactor and outgoing handoff attempts.
+     */
+    async deliverAggregateEvent(repository, routing, message, deliveryTenantId) {
+        const runtime = repositoryRuntimes.get(repository);
+        if (runtime === undefined) {
+            throw new Error("Aggregate inbox delivery requires a bound repository runtime.");
+        }
+        const event = InboxMessages.readEntityInboxEvent(message);
+        InboxDelivery.validateEventTenant(runtime.context, deliveryTenantId, event);
+        InboxDelivery.validateDeliveredEventPayload(routing, event, "Aggregate inbox delivery requires a readable event payload.");
+        const route = InboxDelivery.deliverEventRoute(repository, routing, message, event, "Aggregate inbox delivery");
+        const [entityId] = route.entityIds;
+        await DispatchGuards.guardedEntityEventDispatch(repository, runtime, event, entityId, () => new AggregateEventExecution(repository, routing, runtime, event).runTarget(entityId, route));
+    },
+    /**
+     * Routes Process Manager Command or Event deliver by its stored operation label.
      *
      * @param repository Process Manager repository receiving the signal.
      * @param routing Registered handlers and message schemas.
      * @param message Stored Inbox message with the recorded target.
      * @param deliveryTenantId Tenant selected by delivery in a multitenant context.
-     * @returns Any Command follow-up work that must wait for Inbox completion.
+     * @returns Completion after processing and outgoing handoff attempts.
      */
-    async replayPmInbox(repository, routing, message, deliveryTenantId) {
+    async deliverPmInbox(repository, routing, message, deliveryTenantId) {
         if (repository.entityFamily === "agent") {
-            await InboxReplay.replayAgentInbox(repository, routing, message, deliveryTenantId);
+            await InboxDelivery.deliverAgentInbox(repository, routing, message, deliveryTenantId);
             return undefined;
         }
         if (message.label === "HANDLE_COMMAND") {
-            return await InboxReplay.replayProcessManagerCommand(repository, routing, message, deliveryTenantId);
+            await InboxDelivery.deliverProcessManagerCommand(repository, routing, message, deliveryTenantId);
+            return;
         }
         if (message.label === "REACT_UPON_EVENT") {
-            await InboxReplay.replayProcessManagerEvent(repository, routing, message, deliveryTenantId);
+            await InboxDelivery.deliverProcessManagerEvent(repository, routing, message, deliveryTenantId);
             return undefined;
         }
-        throw new Error(`Entity Inbox replay does not handle "${message.label}" messages.`);
+        throw new Error(`Entity Inbox delivery does not handle "${message.label}" messages.`);
     },
     /**
      * Persists selected Agent work before the normal Inbox acknowledges delivery.
@@ -7378,17 +7404,17 @@ const InboxReplay = {
      * @param deliveryTenantId Tenant selected by delivery.
      * @returns When the fenced repository operation completes.
      */
-    async replayAgentInbox(repository, routing, message, deliveryTenantId) {
+    async deliverAgentInbox(repository, routing, message, deliveryTenantId) {
         const runtime = repositoryRuntimes.get(repository);
         if (runtime === undefined)
-            throw new Error("Agent Inbox replay requires a bound runtime.");
+            throw new Error("Agent Inbox delivery requires a bound runtime.");
         if (message.label === "HANDLE_COMMAND") {
-            await InboxReplay.replayAgentCommand(repository, routing, runtime, message, deliveryTenantId);
+            await InboxDelivery.deliverAgentCommand(repository, routing, runtime, message, deliveryTenantId);
             return;
         }
         if (message.label !== "REACT_UPON_EVENT")
-            throw new Error(`Agent Inbox replay does not handle "${message.label}" messages.`);
-        await InboxReplay.replayAgentEvent(repository, routing, runtime, message, deliveryTenantId);
+            throw new Error(`Agent Inbox delivery does not handle "${message.label}" messages.`);
+        await InboxDelivery.deliverAgentEvent(repository, routing, runtime, message, deliveryTenantId);
     },
     /**
      * Admits a Command using its stored target and registered assignee.
@@ -7400,15 +7426,15 @@ const InboxReplay = {
      * @param tenantId Delivery tenant.
      * @returns When the fenced repository operation completes.
      */
-    async replayAgentCommand(repository, routing, runtime, message, tenantId) {
+    async deliverAgentCommand(repository, routing, runtime, message, tenantId) {
         const command = InboxMessages.readInboxCommand(message);
-        InboxReplay.validateReplayTenant(runtime.context, tenantId, command);
-        InboxReplay.validateReplayedCommandPayload(routing, command);
-        const route = InboxReplay.replayCommandRoute(repository, routing, message, command);
+        InboxDelivery.validateDeliveryTenant(runtime.context, tenantId, command);
+        InboxDelivery.validateDeliveredCommandPayload(routing, command);
+        const route = InboxDelivery.deliverCommandRoute(repository, routing, message, command);
         const assignee = routing.commandReadiness?.findCommandAssignee(route.messageFullTypeName);
         if (assignee === undefined)
             throw new Error("Agent Command has no selected assignee.");
-        await InboxReplay.admitAgent(repository, runtime, message, tenantId, route.entityId, { case: "command", value: command }, [assignee.registeredHandler]);
+        await InboxDelivery.admitAgent(repository, runtime, message, tenantId, route.entityId, { case: "command", value: command }, [assignee.registeredHandler]);
     },
     /**
      * Admits matching Event handlers from the stored target without rerouting.
@@ -7420,15 +7446,15 @@ const InboxReplay = {
      * @param tenantId Delivery tenant.
      * @returns When the fenced repository operation completes.
      */
-    async replayAgentEvent(repository, routing, runtime, message, tenantId) {
-        const event = InboxMessages.readPmInboxEvent(message);
-        InboxReplay.validatePmReplayTenant(runtime.context, tenantId, event);
-        InboxReplay.validateReplayedEventPayload(routing, event, "Agent Inbox replay requires an Event payload.");
-        const route = InboxReplay.replayEventRoute(repository, routing, message, event, "Agent Inbox replay");
-        const handlers = InboxReplay.agentEventHandlers(routing, route.messageFullTypeName, event);
+    async deliverAgentEvent(repository, routing, runtime, message, tenantId) {
+        const event = InboxMessages.readEntityInboxEvent(message);
+        InboxDelivery.validateEventTenant(runtime.context, tenantId, event);
+        InboxDelivery.validateDeliveredEventPayload(routing, event, "Agent Inbox delivery requires an Event payload.");
+        const route = InboxDelivery.deliverEventRoute(repository, routing, message, event, "Agent Inbox delivery");
+        const handlers = InboxDelivery.agentEventHandlers(routing, route.messageFullTypeName, event);
         if (handlers.length === 0)
             return;
-        await InboxReplay.admitAgent(repository, runtime, message, tenantId, route.entityIds[0], { case: "event", value: event }, handlers);
+        await InboxDelivery.admitAgent(repository, runtime, message, tenantId, route.entityIds[0], { case: "event", value: event }, handlers);
     },
     /**
      * Restores selected Event and Command reactions from the original payload.
@@ -7467,14 +7493,14 @@ const InboxReplay = {
         if (deliverySignal === undefined)
             throw new Error("Agent admission requires delivery scope.");
         const cancellation = AbortSignal.any([deliverySignal, runtime.agentSignal]);
-        const key = InboxReplay.capacityKeyFor(repository, input.context, input.id.key(entityId));
+        const key = InboxDelivery.capacityKeyFor(repository, input.context, input.id.key(entityId));
         const reservation = runtime.reserveAgent(key, cancellation);
         if (reservation === undefined) {
             runtime.deferAgent(message, tenantId);
             AgentDeliveryScope.record({ kind: "deferred" });
             return;
         }
-        await InboxReplay.admitReservedAgent({
+        await InboxDelivery.admitReservedAgent({
             repository,
             runtime,
             context: input.context,
@@ -7516,13 +7542,13 @@ const InboxReplay = {
     async admitReservedAgent(input) {
         const { repository, runtime, context, message, signal, reservation } = input;
         try {
-            const accepted = await InboxReplay.acceptAgentReceipt(runtime, context, repository, message, signal);
+            const accepted = await InboxDelivery.acceptAgentReceipt(runtime, context, repository, message, signal);
             if (!accepted) {
                 reservation.release();
                 AgentDeliveryScope.record({ kind: "duplicate" });
                 return;
             }
-            InboxReplay.recordAcceptedAgent(input);
+            InboxDelivery.recordAcceptedAgent(input);
         }
         catch (error) {
             reservation.release();
@@ -7547,7 +7573,7 @@ const InboxReplay = {
             },
             run: (fence, checkSession) => {
                 const cancellation = AbortSignal.any([fence, runtime.agentSignal]);
-                const checkAgentSession = InboxReplay.agentSessionGuard(cancellation, checkSession);
+                const checkAgentSession = InboxDelivery.agentSessionGuard(cancellation, checkSession);
                 return reservation.run(() => withDeliveryCommitFence(checkAgentSession, () => new AgentLiveRunner(repository, runtime, tenantId, entityId, invocation, handlers, cancellation, checkAgentSession).run()));
             },
         });
@@ -7576,8 +7602,8 @@ const InboxReplay = {
      */
     acceptAgentReceipt(runtime, context, repository, message, signal) {
         const source = signal.case === "command"
-            ? { kind: "command", id: InboxReplay.requireAgentCommandId(signal.value) }
-            : { kind: "event", id: InboxReplay.requireAgentEventId(signal.value) };
+            ? { kind: "command", id: InboxDelivery.requireAgentCommandId(signal.value) }
+            : { kind: "event", id: InboxDelivery.requireAgentEventId(signal.value) };
         return runtime.agentReceipts.accept(context, {
             stateType: repository.stateSchema.typeName,
             recipientId: message.inboxId.targetId,
@@ -7612,18 +7638,18 @@ const InboxReplay = {
      * @param routing Registered handlers and message schemas.
      * @param message Stored Inbox message with the recorded target.
      * @param deliveryTenantId Tenant selected by delivery in a multitenant context.
-     * @returns Any follow-up work that must wait for Inbox completion.
+     * @returns Completion after processing and outgoing handoff attempts.
      */
-    async replayProcessManagerCommand(repository, routing, message, deliveryTenantId) {
+    async deliverProcessManagerCommand(repository, routing, message, deliveryTenantId) {
         const runtime = repositoryRuntimes.get(repository);
         if (runtime === undefined) {
-            throw new Error("Entity Inbox replay requires a bound repository runtime.");
+            throw new Error("Entity Inbox delivery 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);
+        InboxDelivery.validateDeliveryTenant(runtime.context, deliveryTenantId, command);
+        InboxDelivery.validateDeliveredCommandPayload(routing, command);
+        const route = InboxDelivery.deliverCommandRoute(repository, routing, message, command);
+        await new ProcessManagerCommandExecution(repository, routing, runtime, command).run(route);
     },
     /**
      * Dispatches a validated Event to the Process Manager target recorded in its Inbox.
@@ -7634,15 +7660,15 @@ const InboxReplay = {
      * @param deliveryTenantId Tenant selected by delivery in a multitenant context.
      * @returns Completion of dispatch to the recorded target.
      */
-    async replayProcessManagerEvent(repository, routing, message, deliveryTenantId) {
+    async deliverProcessManagerEvent(repository, routing, message, deliveryTenantId) {
         const runtime = repositoryRuntimes.get(repository);
         if (runtime === undefined) {
-            throw new Error("Entity Inbox replay requires a bound repository runtime.");
+            throw new Error("Entity Inbox delivery 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 event = InboxMessages.readEntityInboxEvent(message);
+        InboxDelivery.validateEventTenant(runtime.context, deliveryTenantId, event);
+        InboxDelivery.validateDeliveredEventPayload(routing, event, "Entity Inbox delivery requires a readable event payload.");
+        const route = InboxDelivery.deliverEventRoute(repository, routing, message, event, "Entity Inbox delivery");
         const [entityId] = route.entityIds;
         await new ProcessManagerEventExecution(repository, routing, runtime, event).runTarget(entityId, route);
     },
@@ -7655,34 +7681,34 @@ const InboxReplay = {
      * @param deliveryTenantId Tenant selected by delivery in a multitenant context.
      * @returns Completion of dispatch to the recorded target.
      */
-    async replayProjectionEvent(repository, routing, message, deliveryTenantId) {
+    async deliverProjectionEvent(repository, routing, message, deliveryTenantId) {
         const runtime = repositoryRuntimes.get(repository);
         if (runtime === undefined) {
-            throw new Error("Projection inbox replay requires a bound repository runtime.");
+            throw new Error("Projection inbox delivery 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");
+        InboxDelivery.validateProjectionDeliveryTenant(runtime.context, deliveryTenantId, event);
+        InboxDelivery.validateDeliveredEventPayload(routing, event);
+        const route = InboxDelivery.deliverEventRoute(repository, routing, message, event, "Projection inbox delivery");
         const [entityId] = route.entityIds;
         await new ProjectionEventExecution(repository, routing, runtime, event).runTarget(entityId, route);
     },
     /**
-     * Routes a Projection Inbox message to domain Event or Entity-state update replay.
+     * Routes a Projection Inbox message to domain Event or Entity-state update deliver.
      *
      * @param repository Projection repository receiving the update.
      * @param routing Registered subscribers and message schemas.
      * @param message Stored Projection Inbox message.
      * @param deliveryTenantId Tenant selected by delivery in a multitenant context.
-     * @returns Completion of the selected replay operation.
+     * @returns Completion of the selected deliver operation.
      */
-    async replayProjectionMessage(repository, routing, message, deliveryTenantId) {
+    async deliverProjectionMessage(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);
+            await InboxDelivery.deliverProjectionStateUpdate(repository, routing, message, event, deliveryTenantId);
             return;
         }
-        await InboxReplay.replayProjectionEvent(repository, routing, message, deliveryTenantId);
+        await InboxDelivery.deliverProjectionEvent(repository, routing, message, deliveryTenantId);
     },
     /**
      * Dispatches an Entity-state update to the Projection target recorded in its Inbox.
@@ -7694,12 +7720,12 @@ const InboxReplay = {
      * @param deliveryTenantId Tenant selected by delivery in a multitenant context.
      * @returns Completion of state-subscriber dispatch to the recorded target.
      */
-    async replayProjectionStateUpdate(repository, routing, message, event, deliveryTenantId) {
+    async deliverProjectionStateUpdate(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);
+            throw new Error("Projection inbox delivery requires a bound repository runtime.");
+        InboxDelivery.validateProjectionDeliveryTenant(runtime.context, deliveryTenantId, event);
+        const route = InboxDelivery.deliverStateUpdateRoute(repository, routing, message, event);
         const [entityId] = route.entityIds;
         const subscribers = route.subscribers;
         await ProjectionEventExecution.runStateTarget(repository, routing, runtime, event, entityId, route, subscribers);
@@ -7708,9 +7734,9 @@ const InboxReplay = {
      * Validates a stored Command against its schema and implicit identifier requirements.
      *
      * @param routing Registered Command schemas.
-     * @param command Envelope whose payload must remain valid on replay.
+     * @param command Envelope whose payload must remain valid on deliver.
      */
-    validateReplayedCommandPayload(routing, command) {
+    validateDeliveredCommandPayload(routing, command) {
         const commandMessage = EntityInvocation.requireSignalMessage(command.message, "command");
         const commandSchema = RepositoryRoutes.schemaForTypeUrl(routing.commandSchemas, commandMessage.typeUrl, "command");
         const payload = AnyPacker.tryUnpack(commandMessage, commandSchema);
@@ -7735,10 +7761,10 @@ const InboxReplay = {
      * Unpacks and validates a stored Event against its registered schema.
      *
      * @param routing Registered Event schemas.
-     * @param event Envelope whose payload must remain valid on replay.
+     * @param event Envelope whose payload must remain valid on deliver.
      * @param invalidPayloadMessage Error text used when the payload cannot be unpacked.
      */
-    validateReplayedEventPayload(routing, event, invalidPayloadMessage = "Projection inbox replay requires a readable event payload.") {
+    validateDeliveredEventPayload(routing, event, invalidPayloadMessage = "Projection inbox delivery requires a readable event payload.") {
         const eventMessage = EntityInvocation.requireSignalMessage(event.message, "event");
         const eventSchema = RepositoryRoutes.schemaForTypeUrl(routing.eventSchemas, eventMessage.typeUrl, "event");
         const payload = AnyPacker.tryUnpack(eventMessage, eventSchema);
@@ -7748,69 +7774,69 @@ const InboxReplay = {
         Validate.check(eventSchema, payload);
     },
     /**
-     * Checks that a replayed Command's tenant matches its delivery tenant.
+     * Checks that a delivered Command's tenant matches its delivery tenant.
      *
      * @param context Context name and tenant mode; single-tenant contexts need no check.
      * @param deliveryTenantId Tenant selected by Inbox delivery.
      * @param command Stored Command containing the original actor context.
      */
-    validateReplayTenant(context, deliveryTenantId, command) {
+    validateDeliveryTenant(context, deliveryTenantId, command) {
         if (!context.multitenant) {
             return;
         }
         if (deliveryTenantId === undefined) {
-            throw new Error(`Multitenant Entity Inbox replay for "${context.name}" requires tenantId.`);
+            throw new Error(`Multitenant Entity Inbox delivery for "${context.name}" requires tenantId.`);
         }
         const envelopeTenantId = RepositoryTenants.readCommandTenant(command);
         if (envelopeTenantId === undefined) {
-            throw new Error("Entity Inbox replay requires stored command tenant metadata.");
+            throw new Error("Entity Inbox delivery requires stored command tenant metadata.");
         }
         if (!RepositoryTenants.equal(envelopeTenantId, deliveryTenantId)) {
-            throw new Error("Entity Inbox replay stored command tenant does not match.");
+            throw new Error("Entity Inbox delivery stored command tenant does not match.");
         }
     },
     /**
-     * Checks that a replayed Projection Event's tenant matches its delivery tenant.
+     * Checks that a delivered Projection Event's tenant matches its delivery tenant.
      *
      * @param context Context name and tenant mode; single-tenant contexts need no check.
      * @param deliveryTenantId Tenant selected by Inbox delivery.
      * @param event Stored Event containing the original tenant metadata.
      */
-    validateProjectionReplayTenant(context, deliveryTenantId, event) {
+    validateProjectionDeliveryTenant(context, deliveryTenantId, event) {
         if (!context.multitenant) {
             return;
         }
         if (deliveryTenantId === undefined) {
-            throw new Error(`Multitenant projection inbox replay for "${context.name}" requires tenantId.`);
+            throw new Error(`Multitenant projection inbox delivery for "${context.name}" requires tenantId.`);
         }
         const envelopeTenantId = RepositoryTenants.readEventTenant(event);
         if (envelopeTenantId === undefined) {
-            throw new Error("Projection inbox replay requires stored event tenant metadata.");
+            throw new Error("Projection inbox delivery requires stored event tenant metadata.");
         }
         if (!RepositoryTenants.equal(envelopeTenantId, deliveryTenantId)) {
-            throw new Error("Projection inbox replay stored event tenant does not match.");
+            throw new Error("Projection inbox delivery stored event tenant does not match.");
         }
     },
     /**
-     * Checks that a replayed Process Manager Event's tenant matches its delivery tenant.
+     * Checks that a delivered Entity Event's tenant matches its delivery tenant.
      *
      * @param context Context name and tenant mode; single-tenant contexts need no check.
      * @param deliveryTenantId Tenant selected by Inbox delivery.
      * @param event Stored Event containing the original tenant metadata.
      */
-    validatePmReplayTenant(context, deliveryTenantId, event) {
+    validateEventTenant(context, deliveryTenantId, event) {
         if (!context.multitenant) {
             return;
         }
         if (deliveryTenantId === undefined) {
-            throw new Error(`Multitenant Entity Inbox replay for "${context.name}" requires tenantId.`);
+            throw new Error(`Multitenant Entity Inbox delivery for "${context.name}" requires tenantId.`);
         }
         const envelopeTenantId = RepositoryTenants.readEventTenant(event);
         if (envelopeTenantId === undefined) {
-            throw new Error("Entity Inbox replay requires stored event tenant metadata.");
+            throw new Error("Entity Inbox delivery requires stored event tenant metadata.");
         }
         if (!RepositoryTenants.equal(envelopeTenantId, deliveryTenantId)) {
-            throw new Error("Entity Inbox replay stored event tenant does not match.");
+            throw new Error("Entity Inbox delivery stored event tenant does not match.");
         }
     },
     /**
@@ -7822,10 +7848,10 @@ const InboxReplay = {
      * @param command Stored Command used to identify the registered handler schema.
      * @returns A deferred route to the recorded Entity identifier.
      */
-    replayCommandRoute(repository, routing, message, command) {
+    deliverCommandRoute(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.");
+            throw new Error("Entity Inbox delivery 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");
@@ -7842,13 +7868,13 @@ const InboxReplay = {
      * @param routing Registered Event schemas.
      * @param message Inbox message recording the target type and identifier.
      * @param event Stored Event used to identify the registered handler schema.
-     * @param replayName Operation name used when reporting a target-type mismatch.
+     * @param deliverName Operation name used when reporting a target-type mismatch.
      * @returns A deferred route containing exactly the recorded target identifier.
      */
-    replayEventRoute(repository, routing, message, event, replayName) {
+    deliverEventRoute(repository, routing, message, event, deliverName) {
         const expectedTargetTypeUrl = TypeUrls.derive(repository.stateSchema);
         if (message.inboxId.targetTypeUrl !== expectedTargetTypeUrl) {
-            throw new Error(`${replayName} stored target type does not match the routed repository.`);
+            throw new Error(`${deliverName} 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");
@@ -7869,15 +7895,15 @@ const InboxReplay = {
      * @param event Stored Entity-state update envelope.
      * @returns A deferred route with the unpacked state and matching subscribers.
      */
-    replayStateUpdateRoute(repository, routing, message, event) {
+    deliverStateUpdateRoute(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.");
+            throw new Error("Projection inbox delivery stored target type does not match the routed repository.");
         }
-        const update = RepositoryRoutes.decodeStateUpdate(event, routing.stateSchemas, "Projection inbox replay");
+        const update = RepositoryRoutes.decodeStateUpdate(event, routing.stateSchemas, "Projection inbox delivery");
         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.");
+            throw new Error("Projection inbox delivery requires a readable stored Entity state update.");
         }
         const { schema, state } = update;
         const entityId = InboxMessages.targetEntityId(message.inboxId.targetId, repository.idField);
@@ -7886,7 +7912,7 @@ const InboxReplay = {
             entityIds,
             messageFullTypeName: schema.typeName,
             state,
-            subscribers: InboxReplay.stateSubscribers(routing, schema, event),
+            subscribers: InboxDelivery.stateSubscribers(routing, schema, event),
             invocation: "deferred",
         });
     },
@@ -7903,7 +7929,7 @@ const InboxReplay = {
         return Object.freeze(candidates.filter((subscriber) => (subscriber.handler.origin === "external") === (event.context?.external === true)));
     },
 };
-Object.freeze(InboxReplay);
+Object.freeze(InboxDelivery);
 /**
  * Records routed signals in the appropriate Entity or Projection Inbox.
  */
@@ -7914,7 +7940,7 @@ const InboxHandoff = {
      * @param repository Repository supplying the Command route and Entity type.
      * @param runtime Inbox, storage, tenant mode, and delivery strategy.
      * @param command Command envelope to retain and deliver.
-     * @returns Completion of Inbox receipt and its selected delivery operation.
+     * @returns Completion after Inbox receipt and eligible delivery scheduling.
      * @param acceptedRoute Recipient route saved when the signal was accepted.
      */
     async handoffEntityCommand(repository, runtime, command, acceptedRoute) {
@@ -7942,7 +7968,7 @@ const InboxHandoff = {
      * @param runtime Projection Inbox, storage, and tenant mode.
      * @param event Event envelope to retain and deliver.
      * @param entityId Routed Projection identifier.
-     * @returns Completion of Inbox receipt and delivery.
+     * @returns Completion after Inbox receipt and eligible delivery scheduling.
      */
     async handoffProjectionEvent(repository, runtime, event, entityId) {
         const eventId = RepositorySignals.requireEventId(event);
@@ -7963,53 +7989,53 @@ const InboxHandoff = {
         }, deliveryTenantId);
     },
     /**
-     * Delivers an Event to one Process Manager target using its Entity Inbox.
+     * Delivers an Event to one Entity target using its Inbox.
      *
-     * @param repository Repository supplying the Process Manager type and ID descriptor.
+     * @param repository Repository supplying the Entity type and ID descriptor.
      * @param runtime Entity Inbox, storage, tenant mode, and delivery strategy.
      * @param event Event envelope to retain and deliver.
-     * @param entityId Routed Process Manager identifier.
-     * @returns Completion of Inbox receipt and its selected delivery operation.
+     * @param entityId Routed Entity identifier.
+     * @returns Completion after Inbox receipt and eligible delivery scheduling.
      */
-    async handoffPmEvent(repository, runtime, event, entityId) {
+    async handoffEntityEvent(repository, runtime, event, entityId) {
         const eventId = RepositorySignals.requireEventId(event);
         const keepUntil = new Date(Time.currentTimeMillis() + inboxDedupMs);
-        const deliveryTenantId = RepositoryTenants.requirePmEventTenant(runtime.context, event);
+        const deliveryTenantId = RepositoryTenants.requireEntityEventTenant(runtime.context, event);
         const delivery = serverEnvironmentAccess.coreDelivery(ServerEnvironment.instance());
-        await runtime.entityInbox.receive(delivery, InboxHandoff.pmEventInboxInput(repository, eventId.value, event, entityId, keepUntil), deliveryTenantId);
+        await runtime.entityInbox.receive(delivery, InboxHandoff.entityEventInboxInput(repository, eventId.value, event, entityId, keepUntil), deliveryTenantId);
     },
     /**
-     * Delivers an Event to all routed Process Manager targets through batch receipt.
+     * Delivers an Event to all routed Entity targets through batch receipt.
      *
-     * @param repository Repository supplying the Process Manager type and ID descriptor.
+     * @param repository Repository supplying the Entity type and ID descriptor.
      * @param runtime Entity Inbox, storage, tenant mode, and delivery strategy.
      * @param event Event envelope shared by the target deliveries.
-     * @param entityIds Routed Process Manager identifiers.
-     * @returns Completion of batch receipt and its selected delivery operation.
+     * @param entityIds Routed Entity identifiers.
+     * @returns Completion after batch Inbox receipts and eligible delivery scheduling.
      */
-    async handoffPmEvents(repository, runtime, event, entityIds) {
+    async handoffEntityEvents(repository, runtime, event, entityIds) {
         const eventId = RepositorySignals.requireEventId(event);
         const keepUntil = new Date(Time.currentTimeMillis() + inboxDedupMs);
-        const deliveryTenantId = RepositoryTenants.requirePmEventTenant(runtime.context, event);
+        const deliveryTenantId = RepositoryTenants.requireEntityEventTenant(runtime.context, event);
         const delivery = serverEnvironmentAccess.coreDelivery(ServerEnvironment.instance());
         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));
+                .map((entityId) => InboxHandoff.entityEventInboxInput(repository, eventId.value, event, entityId, keepUntil));
             await runtime.entityInbox.receiveAll(delivery, inputs, deliveryTenantId);
         }
     },
     /**
-     * Builds a pending Process Manager Event delivery for a single target.
+     * Builds a pending Entity Event delivery for a single target.
      *
      * @param repository Repository supplying the target type and ID descriptor.
      * @param signalId Identifier of the original Event.
      * @param event Event envelope to pack without repeating validation.
-     * @param entityId Routed Process Manager identifier.
+     * @param entityId Routed Entity identifier.
      * @param keepUntil Duplicate-retention deadline for this receipt.
      * @returns Input for Entity Inbox receipt.
      */
-    pmEventInboxInput(repository, signalId, event, entityId, keepUntil) {
+    entityEventInboxInput(repository, signalId, event, entityId, keepUntil) {
         return {
             inboxId: {
                 targetId: InboxMessages.inboxTargetId(entityId, repository.idField),
@@ -8025,7 +8051,7 @@ const InboxHandoff = {
 };
 Object.freeze(InboxHandoff);
 /**
- * Connects bus dispatchers and Inbox replay to repository execution.
+ * Connects bus dispatchers and Inbox delivery to repository execution.
  */
 const RepositoryDispatch = {
     /**
@@ -8126,7 +8152,7 @@ const RepositoryDispatch = {
             : RepositoryDispatch.dispatchRepositoryStateUpdate(repository, routing, event, route);
     },
     /**
-     * Creates replay access for an Aggregate or Process Manager with signal handlers.
+     * Creates deliver access for an Aggregate or Process Manager with signal handlers.
      *
      * @param repository Repository providing signal routes and Entity identity.
      * @param routing Registered handlers and message schemas.
@@ -8143,19 +8169,17 @@ const RepositoryDispatch = {
             targetTypeUrl: TypeUrls.derive(repository.stateSchema),
             labels: Object.freeze([
                 ...(routing.commandSchemas.length === 0 ? [] : ["HANDLE_COMMAND"]),
-                ...((repository.entityFamily === "process-manager" ||
-                    repository.entityFamily === "agent") &&
-                    routing.eventSchemas.length > 0
-                    ? ["REACT_UPON_EVENT"]
-                    : []),
+                ...(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),
+            deliver: (message, deliveryTenantId) => repository.entityFamily === "aggregate"
+                ? message.label === "REACT_UPON_EVENT"
+                    ? InboxDelivery.deliverAggregateEvent(repository, routing, message, deliveryTenantId)
+                    : InboxDelivery.deliverAggregateCommand(repository, routing, message, deliveryTenantId)
+                : InboxDelivery.deliverPmInbox(repository, routing, message, deliveryTenantId),
         });
     },
     /**
-     * Creates replay access for a Projection with Event or state subscribers.
+     * Creates deliver access for a Projection with Event or state subscribers.
      *
      * @param repository Repository providing Projection identity and Event routes.
      * @param routing Registered Event and state subscribers.
@@ -8168,7 +8192,7 @@ const RepositoryDispatch = {
         }
         return Object.freeze({
             targetTypeUrl: TypeUrls.derive(repository.stateSchema),
-            replay: (message, deliveryTenantId) => InboxReplay.replayProjectionMessage(repository, routing, message, deliveryTenantId),
+            deliver: (message, deliveryTenantId) => InboxDelivery.deliverProjectionMessage(repository, routing, message, deliveryTenantId),
         });
     },
     /**
@@ -8206,7 +8230,7 @@ const RepositoryDispatch = {
         const route = acceptedRoute ?? (await repository.routeEvent(event));
         switch (repository.entityFamily) {
             case "aggregate":
-                await RepositoryDispatch.dispatchAggregateEvent(repository, routing, runtime, event, route);
+                await RepositoryDispatch.dispatchAggregateEvent(repository, runtime, event, route);
                 return;
             case "process-manager":
             case "agent":
@@ -8221,17 +8245,19 @@ const RepositoryDispatch = {
      * Dispatches an Event to each routed Aggregate with its configured duplicate guard.
      *
      * @param repository Aggregate repository receiving the Event.
-     * @param routing Registered Aggregate Event handlers and schemas.
      * @param runtime Bound storage, publisher, and tenant context.
      * @param event Event envelope to dispatch.
      * @param route Accepted route listing target Aggregate identifiers.
      * @returns Completion of all target dispatches in route order.
      */
-    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 dispatchAggregateEvent(repository, runtime, event, route) {
+        if (route.entityIds.length === 0)
+            return;
+        if (route.entityIds.length === 1) {
+            await InboxHandoff.handoffEntityEvent(repository, runtime, event, route.entityIds[0]);
+            return;
         }
+        await InboxHandoff.handoffEntityEvents(repository, runtime, event, route.entityIds);
     },
     /**
      * Delivers a routed Entity-state update to each target Projection Inbox.