@spine-event-engine/server 2.0.0-snapshot.23 → 2.0.0-snapshot.24

package/dist/repository/repository.js

@@ -19,13 +19,13 @@ import { CommandContextSchema, ActorContextSchema, CommandIdSchema, CommandSchem
 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 { EntityRecordSchema, } from "@spine-event-engine/proto/generated/spine/server/entity/entity_pb.js";
-import { StorageQueryPolicy, } from "@spine-event-engine/storage";
+import { EventStore, StorageQueryPolicy, } from "@spine-event-engine/storage";
 import { TenantBoundary } from "@spine-event-engine/storage/provider";
 import { EntityCommitStorageFactories } from "@spine-event-engine/storage/provider";
 import { AgentHistoryStorageFactories, } from "@spine-event-engine/storage/provider";
 import { AgentExecutionStorageFactories, } from "@spine-event-engine/storage/provider";
 import { AgentHistoryEntrySchema, AgentInvocationTerminatedSchema, AgentModelSelectionChangedSchema as SelectionChangedSchema, AiModelKind, AiDiagnosticIdSchema, ModelRefSchema, ToolEffect, ConversationIdSchema, } from "@spine-event-engine/proto/agent";
-import { AgentInvocationKeySchema, AgentExecutionStartSchema, AgentExecutionCompletionSchema, AgentInvocationBoundsSchema, AgentInvocationStatus, AgentOutgoingSignalSchema, AgentSignalKeySchema, AgentSavedDispatchTargetSchema as SavedTargetSchema, AgentSavedRepositoryFamily, AgentSavedTargetKind, } from "@spine-event-engine/proto/generated/spine/server/agent/execution_record_pb.js";
+import { AgentInvocationKeySchema, AgentExecutionStartSchema, AgentExecutionCompletionSchema, AgentInvocationBoundsSchema, AgentInvocationStatus, AgentOutgoingCommandSchema, AgentSignalKeySchema, AgentSavedDispatchTargetSchema as SavedTargetSchema, AgentSavedRepositoryFamily, AgentSavedTargetKind, } from "@spine-event-engine/proto/generated/spine/server/agent/execution_record_pb.js";
 import { registryOptions } from "@spine-event-engine/ai/spi/runtime";
 import { CommandValidationError } from "../bus/command-errors.js";
 import { SignalPublisher } from "../runtime/signal-publisher.js";
@@ -38,6 +38,7 @@ import { RoutingDeclarations } from "./routing-declarations.js";
 import { EventDispatcherOriginSchemas } from "../bus/event-dispatcher-origin-schemas.js";
 import { SavedDispatcherBindings, } from "../bus/saved-dispatcher-binding.js";
 import { Delivery } from "../delivery/delivery.js";
+import { receptionObservation } from "../delivery/reception-observation.js";
 import { commitFenced } from "./commit-fence.js";
 import { AgentHistoryReads } from "../agent/agent-history.js";
 import { AgentReadRuntime } from "../agent/agent-read-runtime.js";
@@ -438,8 +439,8 @@ const RepositoryAgentReads = {
                 return "accepted";
             case AgentInvocationStatus.AGENT_INVOCATION_ACTIVE:
                 return "active";
-            case AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_DELIVERY:
-                return "completed-pending-delivery";
+            case AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_COMMANDS:
+                return "completed-pending-commands";
             case AgentInvocationStatus.AGENT_INVOCATION_COMPLETED:
                 return "completed";
             case AgentInvocationStatus.AGENT_INVOCATION_TERMINATED:
@@ -2024,25 +2025,32 @@ class ProcessManagerExecutionSupport {
      *
      * @param loaded Process Manager and commit storage.
      * @param options Stand tenant selection.
-     * @param events Produced or diagnostic Events to retain when configured.
-     * @param emitted Domain Events emitted by an Agent, excluding the source Event.
+     * @param diagnostics Input and produced Events to retain when configured.
+     * @param producedEvents Delivery Events to save before current state.
      * @returns `true` after a successful commit or unchanged no-op.
      */
-    async commit(loaded, options, events, emitted = events) {
+    async commit(loaded, options, diagnostics, producedEvents) {
         const version = RepositoryEntities.repositoryVersion(loaded.entity);
         const priorNumber = loaded.current?.version?.number ?? 0;
         if (version.number === priorNumber) {
-            await this.#appendUnchangedDiagnostics(loaded, events);
-            await this.#appendAgentEvents(loaded, emitted);
+            await this.#appendUnchangedDiagnostics(loaded, diagnostics);
+            const store = new EventStore(this.#runtime.context, this.#runtime.storageFactory);
+            try {
+                await store.appendAll(producedEvents);
+            }
+            finally {
+                store.close();
+            }
+            await this.#appendAgentEvents(loaded, producedEvents);
             return true;
         }
         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), this.#repository.metadata);
-        await this.#storeProcessManagerRecord(loaded, entityId, events, deferred);
-        await this.#appendAgentEvents(loaded, emitted);
-        this.#notifyProcessManager(deferred, events);
+        await this.#storeProcessManagerRecord(loaded, entityId, diagnostics, producedEvents, deferred);
+        this.#notifyProcessManager(deferred, diagnostics);
+        await this.#appendAgentEvents(loaded, producedEvents);
         return true;
     }
     /**
@@ -2086,13 +2094,14 @@ class ProcessManagerExecutionSupport {
      *
      * @param loaded Process Manager and commit storage.
      * @param entityId Process Manager identifier.
-     * @param events Diagnostic Events to retain when configured.
+     * @param diagnostics Diagnostic Events to retain when configured.
+     * @param producedEvents Delivery Events to save before current state.
      * @param deferred Stand update to notify or cancel.
      * @returns Completion after durable persistence.
      */
-    async #storeProcessManagerRecord(loaded, entityId, events, deferred) {
+    async #storeProcessManagerRecord(loaded, entityId, diagnostics, producedEvents, deferred) {
         try {
-            await this.#commitProcessManagerRecord(loaded, entityId, events, deferred);
+            await this.#commitProcessManagerRecord(loaded, entityId, diagnostics, producedEvents, deferred);
             entityStateHistoryCaches.get(loaded.entity)?.clear();
         }
         catch (error) {
@@ -2105,11 +2114,12 @@ class ProcessManagerExecutionSupport {
      *
      * @param loaded Loaded Process Manager and commit storage.
      * @param entityId Process Manager identifier.
-     * @param events Diagnostic Events to retain when configured.
+     * @param diagnostics Diagnostic Events to retain when configured.
+     * @param producedEvents Delivery Events to save before current state.
      * @param deferred Stand update containing the prepared record.
      * @returns Completion after the storage commit.
      */
-    #commitProcessManagerRecord(loaded, entityId, events, deferred) {
+    #commitProcessManagerRecord(loaded, entityId, diagnostics, producedEvents, deferred) {
         const history = RepositoryStorage.historyConfiguration(this.#repository);
         const record = RepositoryStand.preparedRecord(this.#repository, deferred, entityId);
         return loaded.commits.commit({
@@ -2119,8 +2129,9 @@ class ProcessManagerExecutionSupport {
             next: record,
             ...(history.stateHistory ? { states: [record] } : {}),
             ...(history.processManagerEventHistory
-                ? { diagnostics: events.map((event) => clone(EventSchema, event)) }
+                ? { diagnostics: diagnostics.map((event) => clone(EventSchema, event)) }
                 : {}),
+            events: producedEvents.map((event) => clone(EventSchema, event)),
         });
     }
     /**
@@ -2217,7 +2228,9 @@ const AgentExecutionRunner = {
      * @returns When the fenced repository operation completes.
      */
     async handleRunFailure(repository, runtime, tenantId, session, error) {
-        if (session.record().status === AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_DELIVERY)
+        if (session.record().status ===
+            AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_COMMANDS ||
+            session.record().status === AgentInvocationStatus.AGENT_INVOCATION_COMPLETED)
             throw error;
         if (error instanceof AgentUncertainAttemptError) {
             const reason = this.hasUnresolvedToolWrite(session.record())
@@ -2248,8 +2261,8 @@ const AgentExecutionRunner = {
             return this.terminate(repository, runtime, tenantId, session, this.hasUnresolvedToolWrite(session.record())
                 ? "TOOL_OUTCOME_UNKNOWN"
                 : "MODEL_OUTCOME_UNKNOWN");
-        if (session.record().status === AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_DELIVERY)
-            return this.deliver(runtime, session);
+        if (session.record().status === AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_COMMANDS)
+            return this.deliverCommands(runtime, session);
         if (this.deadlineExpired(session.record()))
             return this.terminate(repository, runtime, tenantId, session, "DEADLINE_EXCEEDED");
         return this.execute(repository, runtime, tenantId, session);
@@ -2431,9 +2444,8 @@ const AgentExecutionRunner = {
             : await this.selectMissingModels(repository, runtime, session, accepted, tenantId);
         if (session.signal.aborted)
             return;
-        const completed = await this.completeExecution(repository, runtime, tenantId, session, loaded, accepted, handlers, entityId, record.started?.initialVersion ?? create(VersionSchema));
-        if (completed.status === AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_DELIVERY)
-            await this.deliver(runtime, session);
+        const outputs = await this.completeExecution(repository, runtime, tenantId, session, loaded, accepted, handlers, entityId, record.started?.initialVersion ?? create(VersionSchema));
+        await this.deliverInitial(runtime, session, outputs);
     },
     /**
      * Creates or rejects the draft before one conditional Entity completion.
@@ -2451,7 +2463,8 @@ const AgentExecutionRunner = {
      */
     async completeExecution(repository, runtime, tenantId, session, loaded, accepted, handlers, entityId, initialVersion) {
         const outputs = await this.outputsOrRejection(repository, runtime, tenantId, session, loaded.entity, accepted, handlers, entityId, initialVersion);
-        return this.complete(repository, runtime, tenantId, session, loaded, entityId, outputs);
+        await this.complete(repository, runtime, tenantId, session, loaded, entityId, outputs);
+        return outputs;
     },
     /**
      * Rejects a Command draft and persists only its declared rejection.
@@ -2483,22 +2496,20 @@ const AgentExecutionRunner = {
         }
     },
     /**
-     * Wraps the original rejection Event as one pending saved output.
+     * Wraps the original rejection Event for one normal EventBus handoff.
      *
      * @param runtime Bounded Context storage and publication services.
      * @param repository Registered Entity repository for this operation.
      * @param command Original typed Command envelope.
      * @param entityId Typed recipient Entity identifier.
      * @param error Failure raised while processing this accepted signal.
-     * @returns Prepared original rejection Event for durable delivery.
+     * @returns Prepared original rejection Event for one normal EventBus handoff.
      */
     rejectionOutput(runtime, repository, command, entityId, error) {
-        return create(AgentOutgoingSignalSchema, {
-            signal: {
-                case: "event",
-                value: RepositorySignals.rejectionEvent(runtime, repository, command, entityId, error),
-            },
-        });
+        return {
+            case: "event",
+            value: RepositorySignals.rejectionEvent(runtime, repository, command, entityId, error),
+        };
     },
     /**
      * Restores handler results and binds their declared original output envelopes.
@@ -2700,15 +2711,18 @@ const AgentExecutionRunner = {
         const initialVersion = record.started?.initialVersion;
         if (initialVersion === undefined)
             throw new Error("Agent completion requires its started Version.");
+        const commands = outputs
+            .filter((output) => output.case === "command")
+            .map((output) => create(AgentOutgoingCommandSchema, { command: output.value }));
         record.status =
-            outputs.length === 0
+            commands.length === 0
                 ? AgentInvocationStatus.AGENT_INVOCATION_COMPLETED
-                : AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_DELIVERY;
+                : AgentInvocationStatus.AGENT_INVOCATION_COMPLETED_PENDING_COMMANDS;
         record.completion = create(AgentExecutionCompletionSchema, {
             initialVersion,
             resultingVersion: version,
             preferences: [...preferences],
-            outgoing: [...outputs],
+            commands,
         });
         return record;
     },
@@ -2720,9 +2734,9 @@ const AgentExecutionRunner = {
      */
     emittedHistory(outputs) {
         return outputs.flatMap((output) => {
-            if (output.signal.case !== "event" || output.signal.value.context?.rejection !== undefined)
+            if (output.case !== "event" || output.value.context?.rejection !== undefined)
                 return [];
-            const event = output.signal.value;
+            const event = output.value;
             const occurredAt = event.context?.timestamp;
             if (occurredAt === undefined)
                 throw new Error("Agent emitted Event requires its original timestamp.");
@@ -2839,7 +2853,7 @@ const AgentExecutionRunner = {
      * @param version Entity version associated with the signal.
      * @param signal Original domain signal or execution cancellation signal.
      * @param schema Generated message descriptor for the signal.
-     * @returns Typed original Event envelope for durable delivery.
+     * @returns Typed original Event envelope for one normal EventBus handoff.
      */
     bindEventOutput(repository, runtime, source, entityId, version, signal, schema) {
         if (source.case !== "command" && source.case !== "event")
@@ -2852,7 +2866,7 @@ const AgentExecutionRunner = {
             message: AnyMessages.pack(schema, signal),
             context: RepositorySignals.eventContextWithProducer(metadata.context, repository, entityId, version),
         });
-        return create(AgentOutgoingSignalSchema, { signal: { case: "event", value: event } });
+        return { case: "event", value: event };
     },
     /**
      * Creates the original Command envelope from its accepted origin.
@@ -2874,66 +2888,97 @@ const AgentExecutionRunner = {
             message: AnyMessages.pack(schema, signal),
             context: metadata.context,
         });
-        return create(AgentOutgoingSignalSchema, { signal: { case: "command", value: command } });
+        return { case: "command", value: command };
     },
     /**
-     * Publishes saved envelopes through normal bus acceptance before marking original IDs.
+     * Dispatches every emitted Event to the normal EventBus and advances saved Commands.
      *
      * @param runtime Bound normal bus acceptance callbacks.
      * @param session Fenced record containing pending saved envelopes.
+     * @param outputs Locally produced outputs in original handler order.
      * @returns When the fenced repository operation completes.
      */
-    async deliver(runtime, session) {
-        const completed = session.record();
-        const key = completed.accepted?.key;
-        if (key === undefined)
-            throw new Error("Agent output delivery requires its accepted key.");
-        for (const [index, output] of (completed.completion?.outgoing ?? []).entries()) {
+    async deliverInitial(runtime, session, outputs) {
+        let commandIndex = 0;
+        let failed = false;
+        let firstFailure;
+        for (const output of outputs) {
+            try {
+                if (output.case === "event") {
+                    await runtime.publishAgentEvent(output.value);
+                }
+                else {
+                    await this.deliverCommand(runtime, session, commandIndex);
+                }
+            }
+            catch (error) {
+                if (!failed) {
+                    firstFailure = error;
+                    failed = true;
+                }
+            }
+            if (output.case === "command")
+                commandIndex += 1;
+        }
+        if (failed)
+            throw firstFailure;
+    },
+    /**
+     * Retries pending saved Commands without rerunning the Agent handler.
+     *
+     * @param runtime Bound normal Command bus callbacks.
+     * @param session Fenced record containing saved Commands.
+     * @returns Completion after pending Command attempts.
+     */
+    async deliverCommands(runtime, session) {
+        for (const [index] of (session.record().completion?.commands ?? []).entries()) {
             if (session.signal.aborted)
                 return;
-            if (output.delivered)
-                continue;
-            const signal = output.signal;
-            if (signal.case !== "event" && signal.case !== "command")
-                throw new Error("Agent outgoing signal has no original envelope.");
-            const key = this.outputKey(output);
-            const plan = output.plan ??
-                (await (signal.case === "event"
-                    ? runtime.prepareSavedEvent(signal.value)
-                    : runtime.prepareSavedCommand(signal.value)));
-            if (output.plan === undefined) {
-                await session.update((current) => {
-                    const pending = current.completion?.outgoing[index];
-                    if (pending?.plan !== undefined || pending?.signal.case !== signal.case)
-                        throw new Error("Saved Agent output changed before plan installation.");
-                    pending.plan = plan;
-                    return current;
-                });
-            }
-            if (signal.case === "event")
-                await runtime.publishSavedEvent(signal.value, plan);
-            else
-                await runtime.publishSavedCommand(signal.value, plan);
-            await session.markDelivered([key]);
-            runtime.recordAcceptedSaved(signal.value);
+            await this.deliverCommand(runtime, session, index);
         }
     },
     /**
-     * Returns the typed original ID of one completed outgoing signal.
+     * Sends one saved Command under the current claim and records its acknowledgement.
      *
-     * @param output Prepared outgoing domain signal.
-     * @returns Original durable key for the outgoing signal.
+     * @param runtime Bound normal Command bus callbacks.
+     * @param session Fenced record containing saved Commands.
+     * @param index Command position in the saved completion.
+     * @returns Completion after the Command is acknowledged or already delivered.
      */
-    outputKey(output) {
-        if (output.signal.case === "event" && output.signal.value.id !== undefined)
-            return create(AgentSignalKeySchema, {
-                id: { case: "event", value: output.signal.value.id },
-            });
-        if (output.signal.case === "command" && output.signal.value.id !== undefined)
-            return create(AgentSignalKeySchema, {
-                id: { case: "command", value: output.signal.value.id },
+    async deliverCommand(runtime, session, index) {
+        const output = session.record().completion?.commands[index];
+        if (output === undefined || output.delivered)
+            return;
+        const command = output.command;
+        if (command === undefined)
+            throw new Error("Agent outgoing Command has no original envelope.");
+        const key = this.outputKey(output);
+        const plan = output.plan ?? (await runtime.prepareSavedCommand(command));
+        if (output.plan === undefined) {
+            await session.update((current) => {
+                const pending = current.completion?.commands[index];
+                if (pending === undefined ||
+                    pending.plan !== undefined ||
+                    pending.command?.id?.uuid !== command.id?.uuid)
+                    throw new Error("Saved Agent Command changed before plan installation.");
+                pending.plan = plan;
+                return current;
             });
-        throw new Error("Agent outgoing signal requires its original typed ID.");
+        }
+        await runtime.publishSavedCommand(command, plan);
+        await session.markDelivered([key]);
+        runtime.recordAcceptedSaved(command);
+    },
+    /**
+     * Returns the typed original ID of one completed outgoing Command.
+     *
+     * @param output Prepared outgoing Command.
+     * @returns Original durable Command ID.
+     */
+    outputKey(output) {
+        if (output.command?.id !== undefined)
+            return output.command.id;
+        throw new Error("Agent outgoing Command requires its original typed ID.");
     },
     /**
      * Validates every stored binding against the current generated selectors.
@@ -3468,7 +3513,7 @@ class ProcessManagerCommandExecution {
     async #commitAndPublish(loaded, tenantOptions, intake, producedSignals) {
         const commands = this.#commandOutputs(intake.assignee, producedSignals);
         const events = this.#eventOutputs(intake.assignee, producedSignals, intake.route.entityId, RepositoryEntities.priorVersion(loaded.current));
-        const committed = await this.#support.commit(loaded, tenantOptions, events);
+        const committed = await this.#support.commit(loaded, tenantOptions, events, events);
         if (!committed)
             return undefined;
         this.#publishChangedState(loaded, intake.route.entityId);
@@ -3648,7 +3693,7 @@ class ProcessManagerCommandExecution {
     #postEvents(events) {
         for (const event of events) {
             // spine-log-boundary: server.repository_event_follow_up
-            void this.#runtime.publisher.publishEvent(event);
+            void this.#runtime.publisher.publishReactorEvent(event);
         }
     }
 }
@@ -3744,9 +3789,10 @@ class ProcessManagerEventExecution {
         const produced = await this.#invokeHandlers(entityId, loaded.entity, intake, tenantOptions.tenantId);
         const events = this.#bindProducedEvents(produced.events, entityId, RepositoryEntities.priorVersion(loaded.current));
         const commands = this.#bindProducedCommands(produced.commands);
-        const diagnostics = this.#repository.entityFamily === "agent"
-            ? events
-            : [DispatchGuards.guardedJournalEvent(this.#repository, this.#event, entityId), ...events];
+        const diagnostics = [
+            DispatchGuards.guardedJournalEvent(this.#repository, this.#event, entityId),
+            ...events,
+        ];
         const committed = await this.#support.commit(loaded, tenantOptions, diagnostics, events);
         if (!committed)
             return;
@@ -3944,7 +3990,7 @@ class ProcessManagerEventExecution {
     #postEvents(events) {
         for (const event of events) {
             // spine-log-boundary: server.process_manager_event_follow_up
-            void this.#runtime.publisher.publishEvent(event);
+            void this.#runtime.publisher.publishReactorEvent(event);
         }
     }
 }
@@ -4266,7 +4312,23 @@ const EntityInvocation = {
         if (typeof method !== "function") {
             throw new TypeError(`Repository entity execution requires method "${methodName}".`);
         }
-        return Reflect.apply(method, entity, parameterCount === 2 ? [message, context] : [message]);
+        let result;
+        try {
+            result = Reflect.apply(method, entity, parameterCount === 2 ? [message, context] : [message]);
+        }
+        catch (error) {
+            receptionObservation.recordHandlerFailure(error);
+            throw error;
+        }
+        if (result !== null &&
+            (typeof result === "object" || typeof result === "function") &&
+            typeof result.then === "function") {
+            return Promise.resolve(result).catch((error) => {
+                receptionObservation.recordHandlerFailure(error);
+                throw error;
+            });
+        }
+        return result;
     },
     /**
      * Copies a Command context or creates an empty context when absent.
@@ -8007,65 +8069,6 @@ const SavedRepositoryDispatch = {
             throw new Error("Saved Agent Command repository binding changed before delivery.");
         return { runtime, signalType: schema.typeName, recipient };
     },
-    /**
-     * Prepares the exact ordered Event recipients and selected generated handlers.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param routing Registered generated handler routing metadata.
-     * @param event Original typed Event envelope.
-     * @returns Validated frozen Event recipient target.
-     */
-    async prepareEvent(repository, routing, event) {
-        const route = await repository.routeEvent(event);
-        return create(SavedTargetSchema, {
-            kind: AgentSavedTargetKind.AGENT_SAVED_REPOSITORY_EVENT,
-            receiverStateType: repository.stateSchema.typeName,
-            repositoryFamily: SavedRepositoryDispatch.family(repository),
-            signalType: route.messageFullTypeName,
-            bindingFingerprint: SavedRepositoryDispatch.fingerprint(repository, SavedRepositoryDispatch.eventHandlers(routing, event)),
-            recipients: route.entityIds.map((id) => InboxMessages.inboxTargetId(id, repository.idField)),
-        });
-    },
-    /**
-     * Restores the saved Event route and current generated handler metadata.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param routing Registered generated handler routing metadata.
-     * @param event Original typed Event envelope.
-     * @param target Frozen recipient binding.
-     * @returns When the fenced repository operation completes.
-     */
-    bindEvent(repository, routing, event, target) {
-        const { signalType } = SavedRepositoryDispatch.requireEventBinding(repository, routing, event, target);
-        const entityIds = target.recipients.map((id) => SavedRepositoryDispatch.recipient(repository, id));
-        const route = {
-            entityIds,
-            messageFullTypeName: signalType,
-            invocation: "deferred",
-        };
-        return Promise.resolve(() => RepositoryDispatch.dispatchRepositoryEvent(repository, routing, event, route));
-    },
-    /**
-     * Checks saved Event metadata and active repository registration.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param routing Registered generated handler routing metadata.
-     * @param event Original typed Event envelope.
-     * @param target Frozen recipient binding.
-     * @returns Registered Event route for the frozen target.
-     */
-    requireEventBinding(repository, routing, event, target) {
-        const packed = EntityInvocation.requireSignalMessage(event.message, "event");
-        const schema = RepositoryRoutes.schemaForTypeUrl(routing.eventSchemas, packed.typeUrl, "event");
-        const fingerprint = SavedRepositoryDispatch.fingerprint(repository, SavedRepositoryDispatch.eventHandlers(routing, event));
-        const runtime = repositoryRuntimes.get(repository);
-        if (!SavedRepositoryDispatch.matches(repository, target, AgentSavedTargetKind.AGENT_SAVED_REPOSITORY_EVENT) ||
-            target.signalType !== schema.typeName ||
-            target.bindingFingerprint !== fingerprint ||
-            runtime === undefined)
-            throw new Error("Saved Agent Event repository binding changed before delivery.");
-        return { runtime, signalType: schema.typeName };
-    },
     /**
      * Creates one internal Command binding from the repository registration.
      *
@@ -8080,20 +8083,6 @@ const SavedRepositoryDispatch = {
             bind: (command, target) => SavedRepositoryDispatch.bindCommand(repository, routing, command, target),
         };
     },
-    /**
-     * Creates one internal Event binding from the repository registration.
-     *
-     * @param repository Registered Entity repository for this operation.
-     * @param routing Registered generated handler routing metadata.
-     * @returns Saved Event binding for this registration.
-     */
-    eventBinding(repository, routing) {
-        return {
-            prepare: (event) => SavedRepositoryDispatch.prepareEvent(repository, routing, event),
-            matches: (target) => SavedRepositoryDispatch.matches(repository, target, AgentSavedTargetKind.AGENT_SAVED_REPOSITORY_EVENT),
-            bind: (event, target) => SavedRepositoryDispatch.bindEvent(repository, routing, event, target),
-        };
-    },
 };
 Object.freeze(SavedRepositoryDispatch);
 /**
@@ -8156,7 +8145,7 @@ const RepositoryDispatch = {
             },
         });
         const originAware = EventDispatcherOriginSchemas.define(dispatcher, routing.domesticEventSchemas, routing.externalEventSchemas);
-        return SavedDispatcherBindings.event(originAware, SavedRepositoryDispatch.eventBinding(repository, routing));
+        return originAware;
     },
     /**
      * Creates a system-Event dispatcher for registered Entity-state subscriptions.