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

package/dist/context/bounded-context.js

@@ -17,9 +17,10 @@ import { isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { clone, create, getOption, hasOption } from "@bufbuild/protobuf";
 import { TypeUrls } from "@spine-event-engine/core";
-import { EventSchema, BoundedContextNameSchema, TenantIdSchema, } from "@spine-event-engine/proto";
+import { EventSchema, EventContextSchema, BoundedContextNameSchema, TenantIdSchema, } from "@spine-event-engine/proto";
 import { SPI_type, internal_all, internal_type } from "@spine-event-engine/proto";
-import { ColumnTypes, EventStore, InMemoryStorageFactory, RecordColumn, TenantBoundary, } from "@spine-event-engine/storage";
+import { ColumnTypes, EventStore, InMemoryStorageFactory, RecordColumn, } from "@spine-event-engine/storage";
+import { TenantBoundary } from "@spine-event-engine/storage/provider";
 import { CommandBus, commandBusAccess } from "../bus/command-bus.js";
 import { EventBus, eventBusAccess, } from "../bus/event-bus.js";
 import { DeliveryReadiness, } from "./local-inbox-handoff.js";
@@ -29,6 +30,7 @@ import { TenantIndexes } from "./tenant-index.js";
 import { Repository, repositoryAccess, } from "../repository/repository.js";
 import { GeneratedRegistryDiscovery } from "../handler/generated-registry-discovery.js";
 import { HandlerRegistryIngestor, } from "../handler/generated-handler-registry.js";
+import { AbstractAssignee, AbstractCommander, AbstractEventReactor, AbstractEventSubscriber, } from "../handler/standalone.js";
 import { HandlerMetadataRegistry, } from "../handler/handler-metadata.js";
 import { SignalMetadata } from "../runtime/signal-metadata.js";
 import { Stand } from "../stand/stand.js";
@@ -37,9 +39,10 @@ import { StorageSubscriptionRegistry, } from "../stand/subscription-registry.js"
 import { UniformAcrossAllShards } from "../delivery/delivery-builder.js";
 import { InboxTargets } from "../delivery/inbox.js";
 import { ShardIndex } from "../delivery/shard-index.js";
-import { emitServerError } from "../server/server-log.js";
 import { IntegrationBroker } from "../integration/integration-broker.js";
 import { ServerEnvironment } from "../server/server-environment.js";
+import { SignalPublisher } from "../runtime/signal-publisher.js";
+import { StandaloneHandlerRuntime, } from "../runtime/standalone-handler-runtime.js";
 /**
  * Error thrown when a bounded context name cannot be accepted.
  */
@@ -64,10 +67,8 @@ export class BoundedContextNameError extends Error {
 const frameworkConstructionToken = Object.freeze({
     frameworkConstructionToken: true,
 });
-const dispatchFailureLimit = 10;
-const dispatchErrorMessageLimit = 500;
-const dispatchErrorStackLimit = 2_000;
 const generatedRegistryFile = "generated/handler/generated-handler-registry.js";
+const errorDetailLimit = 500;
 const moduleSchemeRe = /^[A-Za-z][A-Za-z\d+.-]*:/;
 const internalStoragePrefix = "__spine/";
 const generatedRegistryLoadAttempts = new Map();
@@ -78,9 +79,10 @@ const contextStorageFactories = new WeakMap();
 const contextDeliveryDescriptors = new WeakMap();
 const contextSubscriptionRuntimes = new WeakMap();
 const contextLoggers = new WeakMap();
+const contextSignalPublishers = new WeakMap();
 const contextEventBuses = new WeakMap();
 const closingContexts = new WeakSet();
-const contextDispatchFailureRecorders = new WeakMap();
+const contextClosePhases = new WeakMap();
 const contextIntegrations = new WeakMap();
 const systemEventPosters = new WeakMap();
 const builderBuilds = new WeakMap();
@@ -95,13 +97,13 @@ export class BoundedContext {
     #commandBus;
     #eventBus;
     #systemEventBus;
+    #publisher;
     #commandEndpoint;
     #eventEndpoint;
     #entityInbox;
     #projectionInbox;
     #deliveryStrategy;
     #registeredRepositories = [];
-    #storedEventDispatchFailures = [];
     #repositoryViews = new Set();
     #storageFactory;
     #stand;
@@ -112,36 +114,25 @@ export class BoundedContext {
      * Registers the framework-only construction hook for this module.
      */
     static {
-        constructBoundedContext = (snapshot, commandBus, eventBus, systemEventBus, stand, systemStand, runtime, systemSpec, storageFactory, repositories, deliveryStrategy, token) => new BoundedContext(snapshot, commandBus, eventBus, systemEventBus, stand, systemStand, runtime, systemSpec, storageFactory, repositories, deliveryStrategy, token);
-    }
-    /**
-     * Creates a framework-owned bounded context.
-     *
-     * @param snapshot Contains the immutable context metadata.
-     * @param commandBus Dispatches commands accepted by this context.
-     * @param eventBus Dispatches events accepted by this context.
-     * @param systemEventBus Dispatches framework-only System events.
-     * @param stand Stores read-side state for this context.
-     * @param systemStand Stores read-side state for the paired System Context.
-     * @param subscriptionRuntime Coordinates pair-owned subscription delivery.
-     * @param systemSpec Contains paired System Context metadata.
-     * @param storageFactory Creates context storage.
-     * @param repositories Lists repositories to register.
-     * @param deliveryStrategy Selects immutable Entity Inbox shards.
-     * @param token Proves framework-controlled construction.
+        constructBoundedContext = (input) => new BoundedContext(input);
+    }
+    /**
+     * Creates a Bounded Context from its prepared framework services.
+     *
+     * @param input Prepared services and framework construction token.
      */
-    constructor(snapshot, commandBus, eventBus, systemEventBus, stand, systemStand, subscriptionRuntime, systemSpec, storageFactory, repositories, deliveryStrategy, token) {
-        ContextParts.requireFrameworkConstructionToken(token, "BoundedContext instances are framework-owned.");
-        this.#snapshot = ContextParts.cloneContextSnapshot(snapshot);
-        this.#commandBus = commandBus;
-        this.#eventBus = eventBus;
-        this.#systemEventBus = systemEventBus;
-        contextEventBuses.set(this, [eventBus, systemEventBus]);
-        this.#stand = stand;
-        this.#systemStand = systemStand;
-        this.#subscriptionRuntime = subscriptionRuntime;
-        this.#storageFactory = storageFactory;
-        this.#deliveryStrategy = ContextParts.snapshotDeliveryStrategy(deliveryStrategy);
+    constructor(input) {
+        ContextParts.requireFrameworkConstructionToken(input.token, "BoundedContext instances are framework-owned.");
+        this.#snapshot = ContextParts.cloneContextSnapshot(input.snapshot);
+        this.#commandBus = input.commandBus;
+        this.#eventBus = input.eventBus;
+        this.#systemEventBus = input.systemEventBus;
+        this.#publisher = input.publisher;
+        this.#stand = input.stand;
+        this.#systemStand = input.systemStand;
+        this.#subscriptionRuntime = input.subscriptionRuntime;
+        this.#storageFactory = input.storageFactory;
+        this.#deliveryStrategy = ContextParts.snapshotDeliveryStrategy(input.deliveryStrategy);
         this.#commandEndpoint = Object.freeze({
             acceptedCommandTypes: () => this.#commandBus.acceptedCommandTypes(),
             post: (command) => this.#commandBus.post(command),
@@ -150,9 +141,20 @@ export class BoundedContext {
             acceptedEventTypes: () => ContextParts.exposedEventTypeUrls(this.#eventBus),
             post: (event) => ContextParts.postContextEvent(this, event),
         });
-        contextDispatchFailureRecorders.set(this, (event, error) => {
-            this.#recordDispatchFailure(event, error);
-        });
+        const delivery = this.#createDelivery(input.storageFactory);
+        this.#entityInbox = delivery.entityInbox;
+        this.#projectionInbox = delivery.projectionInbox;
+        this.#installReferences(input, delivery);
+        this.#registerAndStart(input.repositories, delivery.tenantIndex);
+        Object.freeze(this);
+    }
+    /**
+     * Creates tenant-aware Inboxes and their shared readiness signal.
+     *
+     * @param storageFactory Provider supplying the tenant catalog.
+     * @returns Inboxes, tenant index, and readiness signal.
+     */
+    #createDelivery(storageFactory) {
         const deliveryReadiness = new DeliveryReadiness();
         const tenantIndex = TenantIndexes.create({
             contextName: this.#snapshot.name.value,
@@ -160,15 +162,40 @@ export class BoundedContext {
             storageFactory,
         });
         const keepTenant = (tenantId) => tenantIndex.keep(tenantId);
-        this.#entityInbox = new LocalEntityInbox(this.#snapshot.name.value, deliveryReadiness, keepTenant, this.#deliveryStrategy);
-        this.#projectionInbox = new LocalProjectionInbox(this.#snapshot.name.value, deliveryReadiness, keepTenant);
+        const entityInbox = new LocalEntityInbox(this.#snapshot.name.value, deliveryReadiness, keepTenant, this.#deliveryStrategy);
+        const projectionInbox = new LocalProjectionInbox(this.#snapshot.name.value, deliveryReadiness, keepTenant);
+        return { deliveryReadiness, tenantIndex, entityInbox, projectionInbox };
+    }
+    /**
+     * Installs framework references used after context construction.
+     *
+     * @param input Prepared framework services.
+     * @param delivery Tenant index and Inboxes prepared for this context.
+     */
+    #installReferences(input, delivery) {
+        contextEventBuses.set(this, [this.#eventBus, this.#systemEventBus]);
         eventSubscribers.set(this, (typeUrl, subscriber) => eventBusAccess.subscribe(this.#eventBus, typeUrl, subscriber));
-        systemEventPosters.set(this, (event) => this.#systemEventBus.post(event));
-        contextSystemPairings.set(this, ContextParts.createSystemPairing(this.#snapshot, systemSpec));
-        contextTenantIndexes.set(this, tenantIndex);
-        contextStorageFactories.set(this, storageFactory);
-        contextSubscriptionRuntimes.set(this, subscriptionRuntime);
-        contextDeliveryDescriptors.set(this, ContextParts.createDeliveryDescriptor(this.#snapshot, storageFactory, tenantIndex, this.#entityInbox, this.#projectionInbox, deliveryReadiness));
+        systemEventPosters.set(this, (event) => this.#publisher.publishSystemEvent(event));
+        contextSystemPairings.set(this, ContextParts.createSystemPairing(this.#snapshot, input.systemSpec));
+        contextTenantIndexes.set(this, delivery.tenantIndex);
+        contextStorageFactories.set(this, input.storageFactory);
+        contextSubscriptionRuntimes.set(this, this.#subscriptionRuntime);
+        contextSignalPublishers.set(this, this.#publisher);
+        contextClosePhases.set(this, {
+            begin: () => {
+                this.#beginClose();
+            },
+            drain: () => this.#drainWork(),
+        });
+        contextDeliveryDescriptors.set(this, ContextParts.createDeliveryDescriptor(this.#snapshot, input.storageFactory, delivery.tenantIndex, this.#entityInbox, this.#projectionInbox, delivery.deliveryReadiness));
+    }
+    /**
+     * Registers repositories and starts subscriptions, closing the tenant index on failure.
+     *
+     * @param repositories Prepared repositories.
+     * @param tenantIndex Index to close if registration fails.
+     */
+    #registerAndStart(repositories, tenantIndex) {
         try {
             this.#registerRepositories(repositories);
             this.#subscriptionRuntime.start();
@@ -182,7 +209,6 @@ export class BoundedContext {
             }
             throw error;
         }
-        Object.freeze(this);
     }
     #registerRepositories(repositories) {
         const preparedRepositories = this.#prepareRepositories(repositories);
@@ -217,20 +243,13 @@ export class BoundedContext {
             stand: this.#stand,
             entityInbox: this.#entityInbox,
             projectionInbox: this.#projectionInbox,
-            dispatchStored: (event) => eventBusAccess.postStored(this.#eventBus, event),
-            dispatchStoredFollowUp: (event) => eventBusAccess.postStoredFollowUp(this.#eventBus, event),
-            postEventFollowUp: (event) => eventBusAccess.postFollowUp(this.#eventBus, event),
+            publisher: this.#publisher,
             registerEventSchema: (schema) => {
                 eventBusAccess.registerSchemas(this.#eventBus, [schema]);
             },
             registerSystemEventSchema: (schema) => {
                 eventBusAccess.registerSchemas(this.#systemEventBus, [schema]);
             },
-            postSystemFollowUp: (event) => eventBusAccess.postFollowUp(this.#systemEventBus, event),
-            onPostCommand: (command) => commandBusAccess.postInternal(this.#commandBus, command),
-            recordDispatchFailure: (event, error) => {
-                this.#recordDispatchFailure(event, error);
-            },
         };
         const preparedRepositories = [];
         try {
@@ -309,7 +328,7 @@ export class BoundedContext {
         return ContextParts.cloneContextSnapshot(this.#snapshot);
     }
     /**
-     * Returns the command endpoint owned by this context.
+     * Returns this context's command endpoint.
      *
      * @returns Returns the context command endpoint.
      */
@@ -317,7 +336,7 @@ export class BoundedContext {
         return this.#commandEndpoint;
     }
     /**
-     * Returns the event endpoint owned by this context.
+     * Returns this context's event endpoint.
      *
      * @returns Returns the context event endpoint.
      */
@@ -325,7 +344,7 @@ export class BoundedContext {
         return this.#eventEndpoint;
     }
     /**
-     * Returns the context-owned read-side Stand.
+     * Returns the Stand that stores this context's read-side state.
      *
      * @returns Returns the read-side state store.
      */
@@ -340,17 +359,6 @@ export class BoundedContext {
     registeredRepositories() {
         return this.#registeredRepositories.map((snapshot) => ContextParts.createRepositoryView(snapshot));
     }
-    /**
-     * Returns copy-safe diagnostics for asynchronous event follow-up failures.
-     *
-     * Entries can describe already-stored event dispatch or an independent
-     * follow-up post that failed before storage.
-     *
-     * @returns Returns immutable failure diagnostics.
-     */
-    storedEventDispatchFailures() {
-        return this.#storedEventDispatchFailures.map(ContextParts.cloneDispatchFailure);
-    }
     /**
      * Clears and locally replays every registered Projection from already-stored events.
      *
@@ -408,31 +416,54 @@ export class BoundedContext {
         });
     }
     /**
-     * Closes context-owned buses, Stand, and repository storage/runtime bindings.
+     * Closes this context's buses, Stand, and repository storage and runtime bindings.
      *
      * Close is idempotent and returns the same close outcome on repeated calls.
-     * The context attempts every owned close hook; when any hook fails, the
+     * The context attempts every close hook; when any hook fails, the
      * returned promise rejects with an `AggregateError` after the remaining hooks
      * have also been attempted.
      *
-     * @returns A promise that settles after all owned resources close.
+     * @returns A promise that settles after all resources close.
      */
     close() {
-        closingContexts.add(this);
-        eventBusAccess.beginClose(this.#eventBus);
+        this.#beginClose();
         this.#closed ??= this.#closeOnce();
         return this.#closed;
     }
-    async #closeOnce() {
-        const errors = [];
-        await ContextParts.closeContextPart(() => ContextParts.closeIntegration(this), errors);
+    /**
+     * Stops admission to this context's signal and bus work.
+     */
+    #beginClose() {
+        closingContexts.add(this);
+        this.#publisher.beginClose();
         commandBusAccess.beginClose(this.#commandBus);
         eventBusAccess.beginClose(this.#eventBus);
-        await ContextParts.closeContextPart(() => ContextParts.drainContextBuses(this.#commandBus, this.#eventBus), errors);
+        eventBusAccess.beginClose(this.#systemEventBus);
+    }
+    /**
+     * Closes integration intake and drains accepted context work before Stand close.
+     *
+     * @returns Completion after the context's accepted work settles.
+     */
+    async #drainWork() {
+        const errors = [];
+        await ContextParts.closeContextPart(() => ContextParts.closeIntegration(this), errors);
+        await ContextParts.closeContextPart(() => ContextParts.drainContextWork(this.#commandBus, this.#eventBus, this.#systemEventBus, this.#publisher), errors);
+        if (errors.length > 0)
+            throw new AggregateError(errors, "BoundedContext drain failed.");
+    }
+    /**
+     * Closes the context's remaining stores and repository registrations.
+     *
+     * @returns Completion after resource closure.
+     */
+    async #closeOnce() {
+        const errors = [];
+        await ContextParts.closeContextPart(() => this.#drainWork(), errors);
+        this.#publisher.finishClose();
         await ContextParts.closeContextPart(() => commandBusAccess.finishClose(this.#commandBus), errors);
         await ContextParts.closeContextPart(() => eventBusAccess.finishClose(this.#eventBus), errors);
         this.#subscriptionRuntime.beginClose();
-        eventBusAccess.beginClose(this.#systemEventBus);
         await ContextParts.closeContextPart(() => eventBusAccess.drain(this.#systemEventBus), errors);
         await ContextParts.closeContextPart(() => this.#subscriptionRuntime.drainClose(), errors);
         await ContextParts.closeContextPart(() => eventBusAccess.finishClose(this.#systemEventBus), errors);
@@ -442,34 +473,24 @@ export class BoundedContext {
         await ContextParts.closeContextPart(() => {
             ContextParts.requireTenantIndex(this).close();
         }, errors);
-        for (const repository of this.#repositoryViews) {
-            await ContextParts.closeContextPart(() => {
-                repositoryAccess.clearRuntime(repository);
-                registeredRepositories.delete(repository);
-            }, errors);
-        }
+        await this.#closeRepositories(errors);
         if (errors.length > 0) {
             this.#closed = undefined;
             throw new AggregateError(ContextParts.flattenErrors(errors), "BoundedContext close failed.");
         }
         ContextParts.clearContextMetadata(this);
     }
-    #recordDispatchFailure(event, error) {
-        this.#storedEventDispatchFailures.push(Object.freeze({
-            event: clone(EventSchema, event),
-            error: ContextParts.snapshotDispatchError(error),
-        }));
-        if (this.#storedEventDispatchFailures.length > dispatchFailureLimit) {
-            this.#storedEventDispatchFailures.splice(0, this.#storedEventDispatchFailures.length - dispatchFailureLimit);
-        }
-        const logger = contextLoggers.get(this);
-        const eventType = event.message?.typeUrl;
-        if (logger !== undefined && eventType !== undefined && eventType.length > 0) {
-            emitServerError(logger, "Repository follow-up dispatch failed.", {
-                eventType,
-                operation: "repository.follow_up",
-                reasonCode: "dispatch_failed",
-            });
+    /**
+     * Clears repository runtime registration after Stand closure.
+     *
+     * @param errors Failures collected during context closure.
+     */
+    async #closeRepositories(errors) {
+        for (const repository of this.#repositoryViews) {
+            await ContextParts.closeContextPart(() => {
+                repositoryAccess.clearRuntime(repository);
+                registeredRepositories.delete(repository);
+            }, errors);
         }
     }
 }
@@ -477,6 +498,18 @@ export class BoundedContext {
  * Exposes framework-only operations for built contexts and their builders.
  */
 export const boundedContextAccess = Object.freeze({
+    beginClose(context) {
+        const phase = contextClosePhases.get(context);
+        if (phase === undefined)
+            throw new TypeError("Close phase requires a built BoundedContext.");
+        phase.begin();
+    },
+    drainWork(context) {
+        const phase = contextClosePhases.get(context);
+        if (phase === undefined)
+            return Promise.reject(new TypeError("Drain requires a built BoundedContext."));
+        return phase.drain();
+    },
     installLogger(context, logger) {
         if (!contextStorageFactories.has(context)) {
             throw new TypeError("Context logger requires a built BoundedContext instance.");
@@ -488,6 +521,10 @@ export const boundedContextAccess = Object.freeze({
         }
         eventBusAccess.installLogger(buses[0], logger);
         eventBusAccess.installLogger(buses[1], logger);
+        const publisher = contextSignalPublishers.get(context);
+        if (publisher === undefined)
+            throw new TypeError("Context logger requires a built BoundedContext instance.");
+        publisher.installLogger(logger);
         const runtime = contextSubscriptionRuntimes.get(context);
         if (runtime === undefined) {
             throw new TypeError("Context logger requires a built BoundedContext instance.");
@@ -501,13 +538,6 @@ export const boundedContextAccess = Object.freeze({
         }
         return logger;
     },
-    recordDispatchFailure(context, event, error) {
-        const record = contextDispatchFailureRecorders.get(context);
-        if (record === undefined) {
-            throw new TypeError("Dispatch failure recording requires a built BoundedContext instance.");
-        }
-        record(event, error);
-    },
     isBuilder(value) {
         return (typeof value === "object" &&
             value !== null &&
@@ -534,6 +564,19 @@ export const boundedContextAccess = Object.freeze({
         }
         return post(event);
     },
+    postExternalEvent(context, event) {
+        const imported = clone(EventSchema, event);
+        imported.context = clone(EventContextSchema, imported.context ?? create(EventContextSchema));
+        imported.context.external = true;
+        return context.eventBus().post(imported);
+    },
+    observeProducedSignals(context, observer) {
+        const publisher = contextSignalPublishers.get(context);
+        if (publisher === undefined) {
+            throw new TypeError("Produced signal observation requires a built BoundedContext instance.");
+        }
+        return publisher.observe(observer);
+    },
     systemPairing(context) {
         return ContextParts.cloneSystemPairing(ContextParts.requireSystemPairing(context));
     },
@@ -576,6 +619,9 @@ export class BoundedContextBuilder {
     #specSnapshot;
     #commandDispatchers = new Set();
     #eventDispatchers = new Set();
+    #assignees = [];
+    #commanders = [];
+    #eventReceivers = [];
     #repositories = new Set();
     #entityTypes = new Set();
     #generatedRepositoryOptions = new Map();
@@ -591,7 +637,7 @@ export class BoundedContextBuilder {
         constructBoundedContextBuilder = (snapshot, token) => new BoundedContextBuilder(snapshot, token);
     }
     /**
-     * Creates a framework-owned context builder.
+     * Creates a builder from a prepared context specification.
      *
      * @param specSnapshot Contains the initial context specification.
      * @param token Proves framework-controlled construction.
@@ -637,6 +683,7 @@ export class BoundedContextBuilder {
     /**
      * Adds an explicitly assembled repository or an Entity class.
      *
+     * @typeParam EntityType Concrete Entity class represented by this entry.
      * @param entry The repository or Entity class to register.
      * @param options Optional settings used only when an Entity class is supplied.
      * @returns This builder for further configuration.
@@ -659,6 +706,7 @@ export class BoundedContextBuilder {
     /**
      * Removes a repository from the context registration list.
      *
+     * @typeParam EntityType Concrete Entity class represented by the repository.
      * @param repository Identifies the repository to remove.
      * @returns Returns this builder for further configuration.
      */
@@ -670,10 +718,17 @@ export class BoundedContextBuilder {
     /**
      * Adds a command dispatcher to the context being built.
      *
-     * @param dispatcher Dispatches commands accepted by this context.
-     * @returns Returns this builder for further configuration.
+     * @param dispatcher Raw command dispatcher, or an `AbstractCommander` instance.
+     *   A standalone commander requires generated receiver metadata and therefore
+     *   this builder's `buildAsync()` path. It installs its Command and Event sides
+     *   exactly once.
+     * @returns This builder for further configuration.
      */
     addCommandDispatcher(dispatcher) {
+        if (dispatcher instanceof AbstractCommander) {
+            this.#commanders.push(dispatcher);
+            return this;
+        }
         this.#commandDispatchers.add(dispatcher);
         return this;
     }
@@ -690,13 +745,32 @@ export class BoundedContextBuilder {
     /**
      * Adds an event dispatcher to the context being built.
      *
-     * @param dispatcher Dispatches events accepted by this context.
-     * @returns Returns this builder for further configuration.
+     * @param dispatcher Raw event dispatcher, or a standalone reactor/subscriber.
+     *   Standalone receivers require generated receiver metadata and `buildAsync()`.
+     * @returns This builder for further configuration.
      */
     addEventDispatcher(dispatcher) {
+        if (dispatcher instanceof AbstractEventReactor ||
+            dispatcher instanceof AbstractEventSubscriber) {
+            this.#eventReceivers.push(dispatcher);
+            return this;
+        }
         this.#eventDispatchers.add(dispatcher);
         return this;
     }
+    /**
+     * Adds a generated standalone command assignee.
+     *
+     * The registered instance is matched by exact constructor to generated
+     * receiver metadata when `buildAsync()` assembles the context.
+     *
+     * @param assignee Generated standalone assignee instance.
+     * @returns This builder for further configuration.
+     */
+    addAssignee(assignee) {
+        this.#assignees.push(assignee);
+        return this;
+    }
     /**
      * Removes an event dispatcher from the context being built.
      *
@@ -743,7 +817,7 @@ export class BoundedContextBuilder {
         return this;
     }
     /**
-     * Sets the target-to-shard strategy for the context-owned Entity Inbox.
+     * Sets how Entity Inbox targets are assigned to shards.
      *
      * @param strategy Selects the durable shard for Aggregate and Process Manager targets.
      * @returns Returns this builder for further configuration.
@@ -768,11 +842,19 @@ export class BoundedContextBuilder {
      * @returns Returns the built context.
      */
     build() {
+        if (this.#standaloneInstances().length > 0) {
+            throw new Error("Standalone generated handlers require buildAsync().");
+        }
         ContextParts.rejectSyncEntityAssembly(this.#entityTypes);
         return this.#buildWith([...this.#repositories], this.#storageFactory ?? new InMemoryStorageFactory());
     }
     /**
-     * Builds a context after loading generated metadata for added entity classes.
+     * Builds a context after loading generated metadata for added entity classes
+     * and registered standalone handlers.
+     *
+     * Standalone assignees, commanders, reactors, and subscribers require this
+     * asynchronous path so their exact constructors can be matched to generated
+     * receiver metadata.
      *
      * @returns Resolves to the built context.
      */
@@ -780,11 +862,9 @@ export class BoundedContextBuilder {
         return this.#buildAsyncWith();
     }
     async #buildAsyncWith(defaultStorageFactory) {
-        const repositories = [
-            ...this.#repositories,
-            ...(await this.#loadGeneratedRepositories([...this.#entityTypes])),
-        ];
-        const context = this.#buildWith(repositories, this.#storageFactory ?? defaultStorageFactory ?? new InMemoryStorageFactory());
+        const generated = await this.#loadGeneratedArtifacts([...this.#entityTypes]);
+        const repositories = [...this.#repositories, ...generated.repositories];
+        const context = this.#buildWith(repositories, this.#storageFactory ?? defaultStorageFactory ?? new InMemoryStorageFactory(), generated.standalone);
         try {
             await ContextParts.integrationReady(context);
         }
@@ -799,88 +879,146 @@ export class BoundedContextBuilder {
         }
         return context;
     }
-    #buildWith(repositories, storageFactory) {
-        let registry = this.#subscriptionRegistry;
+    #buildWith(repositories, storageFactory, standalone = []) {
+        const resources = this.#subscriptionRegistry === undefined ? {} : { registry: this.#subscriptionRegistry };
         this.#subscriptionRegistry = undefined;
         const registeredRepositories = [...repositories];
-        let eventStore;
-        let systemEventStore;
-        let eventBus;
-        let systemEventBus;
-        let stand;
-        let systemStand;
-        let runtime;
         try {
-            ContextParts.preflightRepositories(registeredRepositories);
-            const eventDispatchers = [
-                ...ContextParts.repositoryEventDispatchers(registeredRepositories),
-                ...this.#eventDispatchers,
-            ];
-            const repositorySystemEventDispatchers = ContextParts.repositorySystemEventDispatchers(registeredRepositories);
-            const domainEventDispatchers = ContextParts.domainEventDispatchers(eventDispatchers);
-            const systemEventDispatchers = [
-                ...ContextParts.systemEventDispatchers(eventDispatchers),
-                ...repositorySystemEventDispatchers,
-            ];
-            const commandBus = new CommandBus([
-                ...this.#commandDispatchers,
-                ...ContextParts.repositoryCommandDispatchers(registeredRepositories),
-            ]);
-            const systemSpec = ContextParts.createSystemSpec(this.#specSnapshot, this.#persistSystemEvents);
-            systemEventStore = systemSpec.storesEvents
-                ? new EventStore(ContextParts.createStorageMode(systemSpec), storageFactory)
-                : undefined;
-            systemEventBus = eventBusAccess.createSystemBus(systemEventStore);
-            for (const dispatcher of systemEventDispatchers)
-                systemEventBus.register(dispatcher);
-            systemStand = new Stand({
-                context: ContextParts.createStorageMode(systemSpec),
-                storageFactory,
-            });
-            eventStore = this.createEventStore(storageFactory);
-            eventBus = new EventBus(eventStore);
-            for (const dispatcher of domainEventDispatchers)
-                eventBus.register(dispatcher);
-            eventBusAccess.registerSchemas(eventBus, ContextParts.repositoryProducedEventSchemas(registeredRepositories));
-            stand = new Stand({
-                context: ContextParts.createStorageMode(this.#specSnapshot),
-                storageFactory,
-            });
-            registry ??= new StorageSubscriptionRegistry(ContextParts.createSubscriptionStorageContext(this.#specSnapshot), storageFactory);
-            runtime = new SubscriptionRuntime(stand, systemStand, eventBus, systemEventBus, registry);
-            const context = ContextParts.createBoundedContext(this.#specSnapshot, commandBus, eventBus, systemEventBus, stand, systemStand, runtime, systemSpec, storageFactory, registeredRepositories, this.#deliveryStrategy);
-            ContextParts.attachIntegration(context, eventBus, systemSpec, ContextParts.externalEventSchemas(domainEventDispatchers));
-            return context;
+            return this.#assembleContext(registeredRepositories, storageFactory, standalone, resources);
         }
         catch (error) {
-            const cleanupErrors = [];
-            ContextParts.attemptCleanup(() => runtime?.abortClose(), cleanupErrors);
-            if (runtime === undefined) {
-                ContextParts.attemptCleanup(() => void registry?.close().catch(() => undefined), cleanupErrors);
-            }
-            ContextParts.attemptCleanup(() => void stand?.close().catch(() => undefined), cleanupErrors);
-            ContextParts.attemptCleanup(() => void systemStand?.close().catch(() => undefined), cleanupErrors);
-            ContextParts.attemptCleanup(() => {
-                if (systemEventBus !== undefined)
-                    eventBusAccess.abortClose(systemEventBus);
-                else if (systemEventStore !== undefined)
-                    systemEventStore.close();
-            }, cleanupErrors);
-            ContextParts.attemptCleanup(() => {
-                if (eventBus !== undefined)
-                    eventBusAccess.abortClose(eventBus);
-                else if (eventStore !== undefined)
-                    eventStore.close();
-            }, cleanupErrors);
-            if (cleanupErrors.length > 0) {
-                throw new AggregateError([error, ...cleanupErrors], "Bounded Context build failed during cleanup.");
-            }
-            throw error;
+            return this.#failBuild(resources, error);
         }
     }
-    async #loadGeneratedRepositories(entityTypes) {
-        if (entityTypes.length === 0) {
-            return Object.freeze([]);
+    #assembleContext(repositories, storageFactory, standalone, resources) {
+        ContextParts.preflightRepositories(repositories);
+        const dispatchers = this.#buildDispatchers(repositories);
+        const buses = this.#buildBuses(repositories, storageFactory, dispatchers, resources);
+        const standaloneEvent = this.#installStandalone(standalone, buses);
+        for (const dispatcher of dispatchers.domain)
+            buses.eventBus.register(dispatcher);
+        eventBusAccess.registerSchemas(buses.eventBus, [
+            ...ContextParts.repositoryProducedEventSchemas(repositories),
+            ...ContextParts.standaloneProducedEventSchemas(standalone),
+        ]);
+        const running = this.#buildRuntime(storageFactory, buses, resources);
+        const context = this.#createContext(repositories, storageFactory, buses, running);
+        ContextParts.attachIntegration(context, buses.eventBus, buses.systemSpec, ContextParts.externalEventSchemas([
+            ...dispatchers.domain,
+            ...(standaloneEvent === undefined ? [] : [standaloneEvent]),
+        ]));
+        return context;
+    }
+    #buildDispatchers(repositories) {
+        const event = [
+            ...ContextParts.repositoryEventDispatchers(repositories),
+            ...this.#eventDispatchers,
+        ];
+        return {
+            domain: ContextParts.domainEventDispatchers(event),
+            system: [
+                ...ContextParts.systemEventDispatchers(event),
+                ...ContextParts.repositorySystemEventDispatchers(repositories),
+            ],
+        };
+    }
+    #buildBuses(repositories, storageFactory, dispatchers, resources) {
+        const commandBus = new CommandBus([
+            ...this.#commandDispatchers,
+            ...ContextParts.repositoryCommandDispatchers(repositories),
+        ]);
+        resources.commandBus = commandBus;
+        const system = this.#buildSystemBuses(storageFactory, dispatchers.system, resources);
+        const eventStore = this.createEventStore(storageFactory);
+        resources.eventStore = eventStore;
+        const eventBus = new EventBus(eventStore);
+        resources.eventBus = eventBus;
+        const publisher = new SignalPublisher(commandBus, eventBus, system.eventBus, this.#specSnapshot.name.value);
+        resources.publisher = publisher;
+        return {
+            commandBus,
+            eventStore,
+            systemEventStore: system.eventStore,
+            eventBus,
+            systemEventBus: system.eventBus,
+            publisher,
+            systemStand: system.stand,
+            systemSpec: system.spec,
+        };
+    }
+    #buildSystemBuses(storageFactory, dispatchers, resources) {
+        const systemSpec = ContextParts.createSystemSpec(this.#specSnapshot, this.#persistSystemEvents);
+        const systemEventStore = systemSpec.storesEvents
+            ? new EventStore(ContextParts.createStorageMode(systemSpec), storageFactory)
+            : undefined;
+        if (systemEventStore !== undefined)
+            resources.systemEventStore = systemEventStore;
+        const systemEventBus = eventBusAccess.createSystemBus(systemEventStore);
+        resources.systemEventBus = systemEventBus;
+        for (const dispatcher of dispatchers)
+            systemEventBus.register(dispatcher);
+        const systemStand = new Stand({
+            context: ContextParts.createStorageMode(systemSpec),
+            storageFactory,
+        });
+        resources.systemStand = systemStand;
+        return {
+            eventStore: systemEventStore,
+            eventBus: systemEventBus,
+            stand: systemStand,
+            spec: systemSpec,
+        };
+    }
+    #installStandalone(standalone, buses) {
+        ContextParts.assertUniqueCommandReceptors(standalone);
+        const runtime = standalone.length === 0
+            ? undefined
+            : new StandaloneHandlerRuntime(ContextParts.matchStandaloneHandlers(standalone, this.#standaloneInstances(), buses.publisher));
+        const command = runtime?.commandDispatcher();
+        const event = runtime?.eventDispatcher();
+        const state = runtime?.stateDispatcher();
+        if (command !== undefined)
+            buses.commandBus.register(command);
+        if (event !== undefined)
+            buses.eventBus.register(event);
+        if (state !== undefined)
+            buses.systemEventBus.register(state);
+        return event;
+    }
+    #buildRuntime(storageFactory, buses, resources) {
+        const stand = new Stand({
+            context: ContextParts.createStorageMode(this.#specSnapshot),
+            storageFactory,
+        });
+        resources.stand = stand;
+        const registry = resources.registry ??
+            new StorageSubscriptionRegistry(ContextParts.createSubscriptionStorageContext(this.#specSnapshot), storageFactory);
+        resources.registry = registry;
+        const runtime = new SubscriptionRuntime(stand, buses.systemStand, buses.eventBus, buses.systemEventBus, registry);
+        resources.runtime = runtime;
+        return { stand, registry, runtime };
+    }
+    #createContext(repositories, storageFactory, buses, running) {
+        return ContextParts.createBoundedContext(this.#specSnapshot, buses.commandBus, buses.eventBus, buses.systemEventBus, buses.publisher, running.stand, buses.systemStand, running.runtime, buses.systemSpec, storageFactory, repositories, this.#deliveryStrategy);
+    }
+    #failBuild(resources, error) {
+        const cleanupErrors = [];
+        ContextParts.attemptCleanup(() => resources.runtime?.abortClose(), cleanupErrors);
+        ContextParts.attemptCleanup(() => resources.publisher?.abortAssembly(), cleanupErrors);
+        if (resources.runtime === undefined) {
+            ContextParts.attemptCleanup(() => void resources.registry?.close().catch(() => undefined), cleanupErrors);
+        }
+        ContextParts.attemptCleanup(() => void resources.stand?.close().catch(() => undefined), cleanupErrors);
+        ContextParts.attemptCleanup(() => void resources.systemStand?.close().catch(() => undefined), cleanupErrors);
+        ContextParts.cleanupBuildBuses(resources, cleanupErrors);
+        if (cleanupErrors.length > 0) {
+            throw new AggregateError([error, ...cleanupErrors], "Bounded Context build failed during cleanup.");
+        }
+        throw error;
+    }
+    async #loadGeneratedArtifacts(entityTypes) {
+        if (entityTypes.length === 0 && this.#standaloneInstances().length === 0) {
+            return Object.freeze({ repositories: Object.freeze([]), standalone: Object.freeze([]) });
         }
         const root = ContextParts.requireGeneratedRegistryRoot(this.#generatedRegistryRoot);
         const discovery = new GeneratedRegistryDiscovery();
@@ -896,8 +1034,19 @@ export class BoundedContextBuilder {
             throw error;
         }));
         const metadata = ContextParts.ingestGeneratedRegistries(registries);
-        return Object.freeze(entityTypes.map((entityType) => ContextParts.createGeneratedRepository(entityType, registries, metadata, this.#generatedRepositoryOptions.get(entityType))));
+        const repositories = Object.freeze(entityTypes.map((entityType) => ContextParts.createGeneratedRepository(entityType, registries, metadata, this.#generatedRepositoryOptions.get(entityType))));
+        const standalone = Object.freeze(registries.flatMap((registry) => registry.receivers.filter((receiver) => receiver.receiverKind === "standalone")));
+        return Object.freeze({ repositories, standalone });
+    }
+    #standaloneInstances() {
+        return Object.freeze([...this.#assignees, ...this.#commanders, ...this.#eventReceivers]);
     }
+    /**
+     * Creates the domain EventStore using this context's storage mode.
+     *
+     * @param storageFactory Storage provider for event records.
+     * @returns Domain EventStore.
+     */
     createEventStore(storageFactory) {
         return new EventStore(ContextParts.createStorageMode(this.#specSnapshot), storageFactory);
     }
@@ -914,7 +1063,7 @@ export class ContextSpec {
         constructContextSpec = (snapshot, token) => new ContextSpec(snapshot, token);
     }
     /**
-     * Creates a framework-owned context specification.
+     * Creates a context specification from prepared values.
      *
      * @param snapshot Contains immutable specification values.
      * @param token Proves framework-controlled construction.
@@ -966,10 +1115,19 @@ export class ContextSpec {
     }
 }
 const registeredRepositories = new WeakMap();
+/**
+ * Reports failure while redispatching a stored event during read-side replay.
+ */
 class CatchUpReplayError extends Error {
     code = "READ_SIDE_CATCH_UP_REPLAY_FAILED";
     eventId;
     detail;
+    /**
+     * Creates a replay error tied to the stored event that failed.
+     *
+     * @param eventId Identifies the stored event.
+     * @param detail Contains the bounded cause name and message.
+     */
     constructor(eventId, detail) {
         super(`Read-side catch-up failed for stored event "${eventId}".`);
         this.name = "ReadCatchUpReplayError";
@@ -982,6 +1140,63 @@ class CatchUpReplayError extends Error {
  * Assembles private bounded-context lifecycle and replay details.
  */
 const ContextParts = Object.freeze({
+    /**
+     * Rejects duplicate command receptors in generated standalone groups.
+     *
+     * @param receivers Generated groups to validate.
+     */
+    assertUniqueCommandReceptors(receivers) {
+        const receptorByType = new Map();
+        for (const receiver of receivers) {
+            for (const handler of receiver.handlers) {
+                if (handler.kind !== "command-assignment" && handler.kind !== "command-substitution")
+                    continue;
+                const typeName = TypeUrls.derive(handler.input.schema);
+                const prior = receptorByType.get(typeName);
+                if (prior !== undefined)
+                    throw new Error(`Standalone command receptors conflict for "${typeName}": ${prior} and ${receiver.receiverType.name}.`);
+                receptorByType.set(typeName, receiver.receiverType.name);
+            }
+        }
+    },
+    /**
+     * Matches generated standalone groups to their registered instances.
+     *
+     * @param generated Generated handler groups.
+     * @param instances Registered standalone instances.
+     * @param publisher Publisher used by bindings.
+     * @returns Frozen bindings in generated order.
+     */
+    matchStandaloneHandlers(generated, instances, publisher) {
+        const byConstructor = new Map();
+        for (const instance of instances) {
+            const constructor = instance.constructor;
+            if (byConstructor.has(constructor)) {
+                throw new Error(`Standalone receiver ${constructor.name} is registered more than once.`);
+            }
+            byConstructor.set(constructor, instance);
+        }
+        const bindings = [];
+        for (const receiver of generated) {
+            const receiverType = receiver.receiverType;
+            const instance = byConstructor.get(receiverType);
+            if (instance === undefined) {
+                throw new Error(`Generated standalone receiver ${receiverType.name} has no explicitly registered instance.`);
+            }
+            bindings.push(Object.freeze({ group: receiver, instance, publisher }));
+            byConstructor.delete(receiverType);
+        }
+        if (byConstructor.size > 0) {
+            throw new Error(`Registered standalone receiver ${[...byConstructor.keys()][0]?.name ?? "unknown"} has no generated metadata.`);
+        }
+        return Object.freeze(bindings);
+    },
+    /**
+     * Calls cleanup and records any thrown error.
+     *
+     * @param onCleanup Cleanup action.
+     * @param errors Collection receiving failures.
+     */
     attemptCleanup(onCleanup, errors) {
         try {
             onCleanup();
@@ -990,39 +1205,136 @@ const ContextParts = Object.freeze({
             errors.push(error);
         }
     },
+    /**
+     * Closes buses and stores after context assembly fails.
+     *
+     * @param resources Partially created resources.
+     * @param errors Collection receiving failures.
+     */
+    cleanupBuildBuses(resources, errors) {
+        ContextParts.attemptCleanup(() => {
+            if (resources.commandBus !== undefined)
+                commandBusAccess.abortClose(resources.commandBus);
+        }, errors);
+        ContextParts.attemptCleanup(() => {
+            if (resources.systemEventBus !== undefined)
+                eventBusAccess.abortClose(resources.systemEventBus);
+            else
+                resources.systemEventStore?.close();
+        }, errors);
+        ContextParts.attemptCleanup(() => {
+            if (resources.eventBus !== undefined)
+                eventBusAccess.abortClose(resources.eventBus);
+            else
+                resources.eventStore?.close();
+        }, errors);
+    },
+    /**
+     * Returns constituent failures from nested aggregate errors.
+     *
+     * @param errors Errors to expand.
+     * @returns Flattened error list.
+     */
     flattenErrors(errors) {
         return errors.flatMap((error) => error instanceof AggregateError ? ContextParts.flattenErrors(error.errors) : [error]);
     },
+    /**
+     * Rejects construction without the framework token.
+     *
+     * @param token Supplied token.
+     * @param message Error message for an invalid token.
+     */
     requireFrameworkConstructionToken(token, message) {
         if (token !== frameworkConstructionToken) {
             throw new TypeError(message);
         }
     },
+    /**
+     * Creates a context specification from its snapshot.
+     *
+     * @param specSnapshot Snapshot used for construction.
+     * @returns Constructed context specification.
+     */
     createContextSpec(specSnapshot) {
         return constructContextSpec(specSnapshot, frameworkConstructionToken);
     },
+    /**
+     * Creates a builder for a context snapshot.
+     *
+     * @param specSnapshot Context configuration snapshot.
+     * @returns Constructed context builder.
+     */
     createBoundedContextBuilder(specSnapshot) {
         return constructBoundedContextBuilder(specSnapshot, frameworkConstructionToken);
     },
-    createBoundedContext(specSnapshot, commandBus, eventBus, systemEventBus, stand, systemStand, runtime, systemSpec, storageFactory, repositories, deliveryStrategy) {
+    /**
+     * Creates a bounded context from assembled runtime components.
+     *
+     * @param specSnapshot Context configuration.
+     * @param commandBus Command dispatch bus.
+     * @param eventBus Domain event bus.
+     * @param systemEventBus System event bus.
+     * @param publisher Signal publisher.
+     * @param stand Domain read-side Stand.
+     * @param systemStand System read-side Stand.
+     * @param runtime Subscription runtime.
+     * @param systemSpec Paired System specification.
+     * @param storageFactory Storage provider.
+     * @param repositories Registered repository views.
+     * @param deliveryStrategy Delivery sharding strategy.
+     * @returns Constructed bounded context.
+     */
+    createBoundedContext(specSnapshot, commandBus, eventBus, systemEventBus, publisher, stand, systemStand, runtime, systemSpec, storageFactory, repositories, deliveryStrategy) {
         return constructBoundedContext({
-            name: specSnapshot.name,
-            tenantMode: ContextParts.toTenantMode(specSnapshot.multitenant),
-            spec: specSnapshot,
-        }, commandBus, eventBus, systemEventBus, stand, systemStand, runtime, systemSpec, storageFactory, repositories, deliveryStrategy, frameworkConstructionToken);
+            snapshot: {
+                name: specSnapshot.name,
+                tenantMode: ContextParts.toTenantMode(specSnapshot.multitenant),
+                spec: specSnapshot,
+            },
+            commandBus,
+            eventBus,
+            systemEventBus,
+            publisher,
+            stand,
+            systemStand,
+            subscriptionRuntime: runtime,
+            systemSpec,
+            storageFactory,
+            repositories,
+            deliveryStrategy,
+            token: frameworkConstructionToken,
+        });
     },
+    /**
+     * Creates the storage mode represented by a context snapshot.
+     *
+     * @param specSnapshot Context configuration snapshot.
+     * @returns Storage mode for the context.
+     */
     createStorageMode(specSnapshot) {
         return Object.freeze({
             name: specSnapshot.name.value,
             multitenant: specSnapshot.multitenant,
         });
     },
+    /**
+     * Creates a non-tenant-scoped subscription storage context.
+     *
+     * @param specSnapshot Context configuration snapshot.
+     * @returns Subscription storage context.
+     */
     createSubscriptionStorageContext(specSnapshot) {
         return Object.freeze({
             name: `${specSnapshot.name.value}:subscriptions`,
             multitenant: false,
         });
     },
+    /**
+     * Captures the shard count and validates later shard results.
+     *
+     * @param strategy Configured delivery strategy.
+     * @returns Immutable delivery strategy snapshot.
+     */
     snapshotDeliveryStrategy(strategy) {
         if (!Number.isSafeInteger(strategy.shardCount) || strategy.shardCount <= 0) {
             throw new Error("Delivery strategy shard count must be a positive safe integer.");
@@ -1030,6 +1342,13 @@ const ContextParts = Object.freeze({
         const shardCount = strategy.shardCount;
         return Object.freeze({
             shardCount,
+            /**
+             * Returns a target shard after verifying the captured shard total.
+             *
+             * @param targetId Inbox target identifier.
+             * @param targetType Inbox target type.
+             * @returns Validated shard index.
+             */
             shardFor(targetId, targetType) {
                 const shard = strategy.shardFor(InboxTargets.clone(targetId), targetType);
                 if (shard.ofTotal !== shardCount) {
@@ -1039,6 +1358,13 @@ const ContextParts = Object.freeze({
             },
         });
     },
+    /**
+     * Creates the storage context for read-side catch-up.
+     *
+     * @param specSnapshot Context configuration.
+     * @param options Catch-up tenant options.
+     * @returns Storage context for the selected scope.
+     */
     catchUpStorageContext(specSnapshot, options) {
         if (!specSnapshot.multitenant) {
             if (options.tenantId !== undefined) {
@@ -1056,6 +1382,12 @@ const ContextParts = Object.freeze({
             tenantId: TenantBoundary.from(tenantId).tenantId,
         });
     },
+    /**
+     * Creates a bounded-context name after checking reserved names.
+     *
+     * @param value Candidate context name.
+     * @returns Immutable validated name.
+     */
     createBoundedContextName(value) {
         if (typeof value !== "string" ||
             value.trim().length === 0 ||
@@ -1064,6 +1396,13 @@ const ContextParts = Object.freeze({
         }
         return Object.freeze({ value });
     },
+    /**
+     * Creates a context snapshot with event storage enabled.
+     *
+     * @param name Context name.
+     * @param multitenant Whether tenant isolation is enabled.
+     * @returns Immutable specification snapshot.
+     */
     createSpecSnapshot(name, multitenant) {
         return Object.freeze({
             name: ContextParts.createBoundedContextName(name),
@@ -1071,9 +1410,21 @@ const ContextParts = Object.freeze({
             storesEvents: true,
         });
     },
+    /**
+     * Copies a bounded-context name into an immutable value.
+     *
+     * @param name Source context name.
+     * @returns Immutable name copy.
+     */
     cloneName(name) {
         return ContextParts.createBoundedContextName(name.value);
     },
+    /**
+     * Copies a context specification snapshot and its name.
+     *
+     * @param spec Source specification.
+     * @returns Immutable specification copy.
+     */
     cloneSpecSnapshot(spec) {
         return Object.freeze({
             name: ContextParts.cloneName(spec.name),
@@ -1081,6 +1432,12 @@ const ContextParts = Object.freeze({
             storesEvents: spec.storesEvents,
         });
     },
+    /**
+     * Copies a bounded-context snapshot and its specification.
+     *
+     * @param snapshot Source context snapshot.
+     * @returns Immutable context snapshot copy.
+     */
     cloneContextSnapshot(snapshot) {
         return Object.freeze({
             name: ContextParts.cloneName(snapshot.name),
@@ -1088,6 +1445,13 @@ const ContextParts = Object.freeze({
             spec: ContextParts.cloneSpecSnapshot(snapshot.spec),
         });
     },
+    /**
+     * Creates the System specification paired with a domain context.
+     *
+     * @param domainSpec Domain specification.
+     * @param storesEvents Whether System events are stored.
+     * @returns System context snapshot.
+     */
     createSystemSpec(domainSpec, storesEvents) {
         return Object.freeze({
             name: ContextParts.createBoundedContextName(`${domainSpec.name.value}_System`),
@@ -1095,24 +1459,49 @@ const ContextParts = Object.freeze({
             storesEvents,
         });
     },
+    /**
+     * Creates a pairing snapshot for domain and System specifications.
+     *
+     * @param snapshot Domain snapshot.
+     * @param systemSpec Paired System specification.
+     * @returns Immutable context pairing.
+     */
     createSystemPairing(snapshot, systemSpec) {
         return Object.freeze({
             domain: ContextParts.cloneContextSnapshot(snapshot),
             system: ContextParts.cloneSpecSnapshot(systemSpec),
         });
     },
+    /**
+     * Copies both specifications in a System pairing.
+     *
+     * @param pairing Pairing to copy.
+     * @returns Immutable pairing copy.
+     */
     cloneSystemPairing(pairing) {
         return Object.freeze({
             domain: ContextParts.cloneContextSnapshot(pairing.domain),
             system: ContextParts.cloneSpecSnapshot(pairing.system),
         });
     },
+    /**
+     * Lists non-internal event type URLs exposed by an event bus.
+     *
+     * @param eventBus Bus whose schemas are inspected.
+     * @returns Frozen exposed type URLs.
+     */
     exposedEventTypeUrls(eventBus) {
         return Object.freeze(eventBusAccess
             .eventSchemas(eventBus)
             .filter((schema) => !ContextParts.isInternalEventSchema(schema))
             .map((schema) => TypeUrls.derive(schema)));
     },
+    /**
+     * Collects external event schemas by type URL.
+     *
+     * @param dispatchers Dispatchers to inspect.
+     * @returns Unique frozen schemas.
+     */
     externalEventSchemas(dispatchers) {
         const schemas = new Map();
         for (const dispatcher of dispatchers) {
@@ -1122,6 +1511,14 @@ const ContextParts = Object.freeze({
         }
         return Object.freeze([...schemas.values()]);
     },
+    /**
+     * Opens the integration broker and associates context readiness.
+     *
+     * @param context Context receiving integration.
+     * @param eventBus Event bus supplied to broker.
+     * @param systemSpec Paired System specification.
+     * @param externalEventSchemas Schemas accepted from outside.
+     */
     attachIntegration(context, eventBus, systemSpec, externalEventSchemas) {
         const broker = new IntegrationBroker({
             contextName: create(BoundedContextNameSchema, { value: context.name.value }),
@@ -1144,6 +1541,13 @@ const ContextParts = Object.freeze({
         void ready.catch(() => undefined);
         contextIntegrations.set(context, { broker, ready });
     },
+    /**
+     * Posts an event after integration readiness and tenant validation.
+     *
+     * @param context Target context.
+     * @param event Event to post.
+     * @returns Promise fulfilled after posting.
+     */
     postContextEvent(context, event) {
         const buses = contextEventBuses.get(context);
         if (buses === undefined)
@@ -1155,15 +1559,34 @@ const ContextParts = Object.freeze({
             return buses[0].post(event);
         });
     },
+    /**
+     * Closes the context integration broker.
+     *
+     * @param context Context whose broker is closed.
+     * @returns Promise fulfilled after closing.
+     */
     closeIntegration(context) {
         return contextIntegrations.get(context)?.broker.close() ?? Promise.resolve();
     },
+    /**
+     * Publishes an imported event through the integration broker.
+     *
+     * @param context Context integration.
+     * @param event Imported event.
+     * @returns Promise fulfilled after publishing.
+     */
     publishImported(context, event) {
         const integration = contextIntegrations.get(context);
         if (integration === undefined)
             return Promise.reject(new Error("Context integration is unavailable."));
         return integration.ready.then(() => integration.broker.publishImported(event));
     },
+    /**
+     * Checks imported event tenant against the context tenant mode.
+     *
+     * @param context Target context.
+     * @param event Imported event to validate.
+     */
     validateImportedTenant(context, event) {
         const tenantId = ContextParts.readReplayTenant(event);
         if (!context.isMultitenant) {
@@ -1177,17 +1600,41 @@ const ContextParts = Object.freeze({
         }
         TenantBoundary.from(tenantId);
     },
+    /**
+     * Waits for the integration broker to become ready.
+     *
+     * @param context Context whose readiness is observed.
+     * @returns Readiness promise.
+     */
     integrationReady(context) {
         return contextIntegrations.get(context)?.ready ?? Promise.resolve();
     },
+    /**
+     * Checks whether a schema carries an internal or SPI marker.
+     *
+     * @param schema Event schema to inspect.
+     * @returns True when an internal marker is set.
+     */
     isInternalEventSchema(schema) {
         return ((hasOption(schema, internal_type) && getOption(schema, internal_type)) ||
             (hasOption(schema, SPI_type) && getOption(schema, SPI_type)) ||
             (hasOption(schema.file, internal_all) && getOption(schema.file, internal_all)));
     },
+    /**
+     * Converts the multitenant flag to a tenant mode.
+     *
+     * @param multitenant Context isolation flag.
+     * @returns Corresponding tenant mode.
+     */
     toTenantMode(multitenant) {
         return multitenant ? "multitenant" : "single-tenant";
     },
+    /**
+     * Reads the System pairing recorded for a built context.
+     *
+     * @param context Context to inspect.
+     * @returns Pairing snapshot; throws if unpaired.
+     */
     requireSystemPairing(context) {
         const pairing = contextSystemPairings.get(context);
         if (pairing === undefined) {
@@ -1195,6 +1642,12 @@ const ContextParts = Object.freeze({
         }
         return pairing;
     },
+    /**
+     * Reads the tenant index recorded for a built context.
+     *
+     * @param context Context to inspect.
+     * @returns Tenant index; throws if unavailable.
+     */
     requireTenantIndex(context) {
         const tenantIndex = contextTenantIndexes.get(context);
         if (tenantIndex === undefined) {
@@ -1202,16 +1655,33 @@ const ContextParts = Object.freeze({
         }
         return tenantIndex;
     },
+    /**
+     * Rejects values that are not Repository instances.
+     *
+     * @param repository Candidate value.
+     * @param operation Operation name included in the error.
+     */
     requireRepositoryInstance(repository, operation) {
         if (!repositoryAccess.hasInstance(repository)) {
             throw new TypeError(`${operation} requires a Repository instance.`);
         }
     },
+    /**
+     * Rejects values that are not Entity classes.
+     *
+     * @param entityType Candidate Entity constructor.
+     * @param operation Operation name included in the error.
+     */
     requireEntityClass(entityType, operation) {
         if (typeof entityType !== "function") {
             throw new TypeError(`${operation} requires a Repository instance. Use an entity class only with buildAsync().`);
         }
     },
+    /**
+     * Rejects synchronous assembly when classes need generated metadata.
+     *
+     * @param entityTypes Entity classes to assemble.
+     */
     rejectSyncEntityAssembly(entityTypes) {
         if (entityTypes.size === 0) {
             return;
@@ -1219,6 +1689,12 @@ const ContextParts = Object.freeze({
         throw new Error("BoundedContextBuilder.build() cannot assemble entity classes from generated metadata. " +
             "Use buildAsync().");
     },
+    /**
+     * Validates that a root exists when generated metadata must be loaded.
+     *
+     * @param root Configured registry location.
+     * @returns Configured root; throws when absent.
+     */
     requireGeneratedRegistryRoot(root) {
         if (root !== undefined) {
             return root;
@@ -1226,6 +1702,12 @@ const ContextParts = Object.freeze({
         throw new Error("BoundedContextBuilder.buildAsync() requires withGeneratedRegistryRoot(root) " +
             "when assembling entity classes from generated metadata.");
     },
+    /**
+     * Resolves the generated registry module and verifies it stays beneath the configured root.
+     *
+     * @param root Configured filesystem path or file URL.
+     * @returns Registry module file URL.
+     */
     async trustedGeneratedRegistryModule(root) {
         const trustedRoot = await ContextParts.canonicalGeneratedRegistryRoot(root);
         const registryPath = resolve(trustedRoot, generatedRegistryFile);
@@ -1236,6 +1718,12 @@ const ContextParts = Object.freeze({
         }
         return pathToFileURL(canonicalRegistryPath);
     },
+    /**
+     * Resolves a generated registry root to its canonical filesystem path.
+     *
+     * @param root Configured path or file URL.
+     * @returns Canonical directory path.
+     */
     async canonicalGeneratedRegistryRoot(root) {
         const rootPath = ContextParts.generatedRegistryRootPath(root);
         try {
@@ -1245,6 +1733,12 @@ const ContextParts = Object.freeze({
             throw new Error(`Generated registry root "${rootPath}" must be an existing readable directory.`, { cause: error });
         }
     },
+    /**
+     * Converts a registry root path or file URL to an absolute filesystem path.
+     *
+     * @param root Configured path or file URL.
+     * @returns Absolute filesystem path.
+     */
     generatedRegistryRootPath(root) {
         if (root instanceof URL) {
             return ContextParts.fileUrlPath(root, "Generated registry root");
@@ -1254,6 +1748,13 @@ const ContextParts = Object.freeze({
         }
         return resolve(root);
     },
+    /**
+     * Validates a file URL and converts it to an absolute filesystem path.
+     *
+     * @param url File URL to convert.
+     * @param label Label used in validation errors.
+     * @returns Filesystem path.
+     */
     fileUrlPath(url, label) {
         if (url.protocol !== "file:") {
             throw new Error(`${label} "${url.href}" must use the file: URL scheme.`);
@@ -1263,6 +1764,12 @@ const ContextParts = Object.freeze({
         }
         return resolve(fileURLToPath(url));
     },
+    /**
+     * Parses a generated registry root string as a URL.
+     *
+     * @param root Registry root string.
+     * @returns Parsed URL.
+     */
     parseRootUrl(root) {
         try {
             return new URL(root);
@@ -1271,9 +1778,21 @@ const ContextParts = Object.freeze({
             throw new Error(`Generated registry root "${root}" is not a valid URL.`, { cause: error });
         }
     },
+    /**
+     * Checks strings for a URL scheme, excluding Windows drive paths.
+     *
+     * @param value String to inspect.
+     * @returns True when the string has a URL scheme.
+     */
     isUrlLike(value) {
         return moduleSchemeRe.test(value) && !/^[A-Za-z]:[\\/]/.test(value);
     },
+    /**
+     * Verifies registry-module readability and resolves its canonical path.
+     *
+     * @param registryPath Registry module filesystem path.
+     * @returns Canonical readable path.
+     */
     async canonicalReadableRegistryPath(registryPath) {
         try {
             await access(registryPath, fsConstants.R_OK);
@@ -1283,6 +1802,13 @@ const ContextParts = Object.freeze({
             throw new Error(`Generated handler registry module "${registryPath}" must exist and be readable.`, { cause: error });
         }
     },
+    /**
+     * Checks whether a canonical path escapes a canonical root.
+     *
+     * @param canonicalRoot Root directory.
+     * @param canonicalPath Candidate path.
+     * @returns True when the candidate escapes the root.
+     */
     resolvesOutsideRoot(canonicalRoot, canonicalPath) {
         const relativePath = relative(canonicalRoot, canonicalPath);
         return (relativePath.startsWith("..") ||
@@ -1290,13 +1816,30 @@ const ContextParts = Object.freeze({
             relativePath.split(sep).includes("..") ||
             isAbsolute(relativePath));
     },
+    /**
+     * Creates a cache-bust query after a prior registry load failure.
+     *
+     * @param registryKey Canonical registry identifier.
+     * @returns Retry query, or an empty object on the first attempt.
+     */
     generatedRegistryCacheBust(registryKey) {
         const attempt = generatedRegistryLoadAttempts.get(registryKey) ?? 0;
         return attempt === 0 ? {} : { cacheBust: `retry-${attempt.toString()}` };
     },
+    /**
+     * Records another failed load for a registry.
+     *
+     * @param registryKey Canonical registry identifier.
+     */
     recordGeneratedRegistryFailure(registryKey) {
         generatedRegistryLoadAttempts.set(registryKey, (generatedRegistryLoadAttempts.get(registryKey) ?? 0) + 1);
     },
+    /**
+     * Loads generated handler registries into a metadata registry.
+     *
+     * @param registries Generated registries to ingest.
+     * @returns Populated handler metadata registry.
+     */
     ingestGeneratedRegistries(registries) {
         const registry = new HandlerMetadataRegistry();
         const ingestor = new HandlerRegistryIngestor();
@@ -1305,6 +1848,15 @@ const ContextParts = Object.freeze({
         }
         return registry;
     },
+    /**
+     * Creates a repository from generated Entity handler metadata.
+     *
+     * @param entityType Entity class.
+     * @param registries Generated registries to search.
+     * @param metadata Ingested handler metadata.
+     * @param options Repository options overriding defaults.
+     * @returns Configured repository view.
+     */
     createGeneratedRepository(entityType, registries, metadata, options) {
         const generated = ContextParts.findGeneratedEntity(entityType, registries);
         const handlers = ContextParts.findGeneratedHandlers(entityType, generated, metadata);
@@ -1316,15 +1868,30 @@ const ContextParts = Object.freeze({
         }, options);
         return new Repository(repositoryOptions);
     },
+    /**
+     * Finds the generated Entity handler group for an Entity class.
+     *
+     * @param entityType Entity class to find.
+     * @param registries Generated registries to search.
+     * @returns Matching handler group; throws when absent.
+     */
     findGeneratedEntity(entityType, registries) {
         for (const registry of registries) {
-            const generated = registry.entities.find((entity) => entity.entityType === entityType);
+            const generated = registry.receivers.find((receiver) => receiver.receiverKind === "entity" && receiver.receiverType === entityType);
             if (generated !== undefined) {
                 return generated;
             }
         }
         throw new Error(`Generated handler registry is missing metadata for ${entityType.name}.`);
     },
+    /**
+     * Finds handler metadata for an Entity class and state schema.
+     *
+     * @param entityType Entity class.
+     * @param generated Matching generated Entity group.
+     * @param metadata Handler metadata registry.
+     * @returns Matching handler metadata; throws when absent.
+     */
     findGeneratedHandlers(entityType, generated, metadata) {
         const matches = metadata.findByState(generated.stateSchema.typeName);
         const handlers = matches.find((candidate) => candidate.entityType === entityType);
@@ -1333,11 +1900,45 @@ const ContextParts = Object.freeze({
         }
         return handlers;
     },
+    /**
+     * Collects event schemas declared as returned or thrown handler outcomes.
+     *
+     * @param generated Generated Entity handler group.
+     * @returns Frozen unique event schemas.
+     */
     aggregateAssignedEvents(generated) {
-        return ContextParts.uniqueSchemas(generated.handlers.flatMap((handler) => handler.kind === "command-assignment" || handler.kind === "event-reaction"
-            ? handler.emittedSchemas
-            : []));
+        return ContextParts.uniqueSchemas(generated.handlers.flatMap((handler) => [
+            ...(handler.kind === "command-assignment" || handler.kind === "event-reaction"
+                ? handler.outcomes.returned
+                : []),
+            ...(handler.kind === "command-assignment" || handler.kind === "command-substitution"
+                ? handler.outcomes.thrown
+                : []),
+        ]));
+    },
+    /**
+     * Collects event schemas produced by standalone handler outcomes.
+     *
+     * @param receivers Generated standalone groups.
+     * @returns Frozen unique event schemas.
+     */
+    standaloneProducedEventSchemas(receivers) {
+        return ContextParts.uniqueSchemas(receivers.flatMap((receiver) => receiver.handlers.flatMap((handler) => [
+            ...(handler.kind === "command-assignment" || handler.kind === "event-reaction"
+                ? handler.outcomes.returned
+                : []),
+            ...(handler.kind === "command-assignment" || handler.kind === "command-substitution"
+                ? handler.outcomes.thrown
+                : []),
+        ])));
     },
+    /**
+     * Returns unique schemas by Protobuf type name, preserving the last schema.
+     *
+     * @typeParam Schema Descriptor schema type retained in the result.
+     * @param schemas Schemas to deduplicate.
+     * @returns Frozen deduplicated schemas.
+     */
     uniqueSchemas(schemas) {
         const byTypeName = new Map();
         for (const schema of schemas) {
@@ -1345,6 +1946,11 @@ const ContextParts = Object.freeze({
         }
         return Object.freeze([...byTypeName.values()]);
     },
+    /**
+     * Validates repository uniqueness, registration state, and projection cycles.
+     *
+     * @param repositories Repository views to validate.
+     */
     preflightRepositories(repositories) {
         const entityTypes = new Set();
         const stateTypeNames = new Set();
@@ -1367,6 +1973,11 @@ const ContextParts = Object.freeze({
         }
         ContextParts.rejectStateCycles(repositories);
     },
+    /**
+     * Rejects cycles among repository state-subscription dependencies.
+     *
+     * @param repositories Repository views whose dependencies are checked.
+     */
     rejectStateCycles(repositories) {
         const dependencies = new Map();
         for (const repository of repositories) {
@@ -1397,30 +2008,66 @@ const ContextParts = Object.freeze({
         for (const stateType of dependencies.keys())
             visit(stateType);
     },
+    /**
+     * Collects command dispatchers configured by repositories.
+     *
+     * @param repositories Repository views to inspect.
+     * @returns Present command dispatchers.
+     */
     repositoryCommandDispatchers(repositories) {
         return repositories.flatMap((repository) => {
             const dispatcher = repositoryAccess.commandDispatcher(repository);
             return dispatcher === undefined ? [] : [dispatcher];
         });
     },
+    /**
+     * Collects event dispatchers configured by repositories.
+     *
+     * @param repositories Repository views to inspect.
+     * @returns Present event dispatchers.
+     */
     repositoryEventDispatchers(repositories) {
         return repositories.flatMap((repository) => {
             const dispatcher = repositoryAccess.eventDispatcher(repository);
             return dispatcher === undefined ? [] : [dispatcher];
         });
     },
+    /**
+     * Collects System event dispatchers configured by repositories.
+     *
+     * @param repositories Repository views to inspect.
+     * @returns Present System event dispatchers.
+     */
     repositorySystemEventDispatchers(repositories) {
         return repositories.flatMap((repository) => {
             const dispatcher = repositoryAccess.systemEventDispatcher(repository);
             return dispatcher === undefined ? [] : [dispatcher];
         });
     },
+    /**
+     * Returns event dispatchers excluding System routes.
+     *
+     * @param dispatchers Event dispatchers to filter.
+     * @returns Frozen domain event dispatchers.
+     */
     domainEventDispatchers(dispatchers) {
         return Object.freeze(dispatchers.filter((dispatcher) => !ContextParts.isSystemEventDispatcher(dispatcher)));
     },
+    /**
+     * Returns System event dispatchers.
+     *
+     * @param dispatchers Event dispatchers to filter.
+     * @returns Frozen System event dispatchers.
+     */
     systemEventDispatchers(dispatchers) {
         return Object.freeze(dispatchers.filter((dispatcher) => ContextParts.isSystemEventDispatcher(dispatcher)));
     },
+    /**
+     * Checks a dispatcher's event family and rejects mixed families.
+     *
+     * @param dispatcher Dispatcher to inspect.
+     * @returns True when its schemas are System event schemas.
+     */
     isSystemEventDispatcher(dispatcher) {
         const schemas = [...dispatcher.messageSchemas()];
         const systemSchemas = schemas.filter((schema) => schema.typeName.startsWith("spine.system."));
@@ -1429,6 +2076,12 @@ const ContextParts = Object.freeze({
         }
         return systemSchemas.length > 0;
     },
+    /**
+     * Collects repository-produced event schemas by type URL.
+     *
+     * @param repositories Repository views to inspect.
+     * @returns Frozen unique event schemas.
+     */
     repositoryProducedEventSchemas(repositories) {
         const schemas = new Map();
         for (const repository of repositories) {
@@ -1438,10 +2091,21 @@ const ContextParts = Object.freeze({
         }
         return Object.freeze([...schemas.values()]);
     },
+    /**
+     * Clears metadata for a failed context build and closes its tenant index.
+     *
+     * @param context Context whose build failed.
+     * @param tenantIndex Tenant index to close.
+     */
     cleanupFailedContext(context, tenantIndex) {
         ContextParts.clearContextMetadata(context);
         tenantIndex.close();
     },
+    /**
+     * Removes runtime metadata associated with a context.
+     *
+     * @param context Context whose WeakMap metadata is removed.
+     */
     clearContextMetadata(context) {
         const buses = contextEventBuses.get(context);
         if (buses !== undefined) {
@@ -1451,7 +2115,8 @@ const ContextParts = Object.freeze({
         const runtime = contextSubscriptionRuntimes.get(context);
         if (runtime !== undefined)
             subscriptionRuntimeAccess.clearLogger(runtime);
-        contextDispatchFailureRecorders.delete(context);
+        contextSignalPublishers.get(context)?.clearLogger();
+        contextSignalPublishers.delete(context);
         contextLoggers.delete(context);
         contextSystemPairings.delete(context);
         contextTenantIndexes.delete(context);
@@ -1462,48 +2127,72 @@ const ContextParts = Object.freeze({
         eventSubscribers.delete(context);
         systemEventPosters.delete(context);
     },
+    /**
+     * Creates delivery operations from the context inboxes and readiness state.
+     *
+     * @param context Built context snapshot.
+     * @param storageFactory Context storage provider.
+     * @param tenantIndex Tenant index for startup scopes.
+     * @param entityInbox Registered Entity inbox.
+     * @param projections Projection inbox.
+     * @param readiness Delivery readiness coordinator.
+     * @returns Delivery descriptor.
+     */
     createDeliveryDescriptor(context, storageFactory, tenantIndex, entityInbox, projections, readiness) {
         return Object.freeze({
             storageFactory,
-            async startupScopes() {
-                if (tenantIndex.tenantMode === "single-tenant") {
-                    return Object.freeze([Object.freeze({})]);
-                }
-                return Object.freeze((await tenantIndex.all()).map((tenantId) => Object.freeze({ tenantId })));
-            },
-            storageContext(scope) {
-                if (context.tenantMode === "single-tenant") {
-                    if (scope.tenantId !== undefined) {
-                        throw new Error(`Single-tenant context "${context.name.value}" does not accept tenantId.`);
-                    }
-                    return Object.freeze({ name: context.name.value, multitenant: false });
-                }
-                const tenantId = scope.tenantId;
-                if (tenantId === undefined) {
-                    throw new Error(`Multitenant context "${context.name.value}" requires tenantId.`);
-                }
-                return Object.freeze({
-                    name: context.name.value,
-                    multitenant: true,
-                    tenantId: TenantBoundary.from(tenantId).tenantId,
-                });
-            },
-            endpoints() {
-                return Object.freeze([...entityInbox.endpoints(), ...projections.endpoints()]);
-            },
-            replay(message, tenantId) {
-                return message.label === "UPDATE_SUBSCRIBER"
-                    ? projections.replay(message, tenantId)
-                    : entityInbox.replay(message, tenantId);
-            },
-            onReady(onReady) {
-                return readiness.onReady(onReady);
-            },
-            transition(scopes, onReady, options) {
-                return readiness.transition(scopes, onReady, options);
-            },
+            startupScopes: () => ContextParts.deliveryStartupScopes(tenantIndex),
+            storageContext: (scope) => ContextParts.deliveryStorageContext(context, scope),
+            endpoints: () => Object.freeze([...entityInbox.endpoints(), ...projections.endpoints()]),
+            replay: (message, tenantId) => message.label === "UPDATE_SUBSCRIBER"
+                ? projections.replay(message, tenantId)
+                : entityInbox.replay(message, tenantId),
+            onReady: (onReady) => readiness.onReady(onReady),
+            transition: (scopes, onReady, options) => readiness.transition(scopes, onReady, options),
+        });
+    },
+    /**
+     * Lists delivery startup scopes, one per tenant in multitenant contexts.
+     *
+     * @param tenantIndex Tenant index supplying configured scopes.
+     * @returns Frozen startup scope list.
+     */
+    async deliveryStartupScopes(tenantIndex) {
+        if (tenantIndex.tenantMode === "single-tenant") {
+            return Object.freeze([Object.freeze({})]);
+        }
+        return Object.freeze((await tenantIndex.all()).map((tenantId) => Object.freeze({ tenantId })));
+    },
+    /**
+     * Creates tenant-validated storage context for a delivery scope.
+     *
+     * @param context Built context snapshot.
+     * @param scope Selected startup scope.
+     * @returns Storage context for the selected tenant.
+     */
+    deliveryStorageContext(context, scope) {
+        if (context.tenantMode === "single-tenant") {
+            if (scope.tenantId !== undefined) {
+                throw new Error(`Single-tenant context "${context.name.value}" does not accept tenantId.`);
+            }
+            return Object.freeze({ name: context.name.value, multitenant: false });
+        }
+        const tenantId = scope.tenantId;
+        if (tenantId === undefined) {
+            throw new Error(`Multitenant context "${context.name.value}" requires tenantId.`);
+        }
+        return Object.freeze({
+            name: context.name.value,
+            multitenant: true,
+            tenantId: TenantBoundary.from(tenantId).tenantId,
         });
     },
+    /**
+     * Closes prepared repositories and collects close failures.
+     *
+     * @param preparedRepositories Prepared repository resources to close.
+     * @returns Collected close errors.
+     */
     closePreparedRepositories(preparedRepositories) {
         const errors = [];
         for (const preparedRepository of preparedRepositories) {
@@ -1516,6 +2205,13 @@ const ContextParts = Object.freeze({
         }
         return errors;
     },
+    /**
+     * Calls one asynchronous context close action and records failures.
+     *
+     * @param close Close operation.
+     * @param errors Failure collection.
+     * @returns Promise fulfilled after the close attempt is recorded.
+     */
     async closeContextPart(close, errors) {
         try {
             await close();
@@ -1524,17 +2220,37 @@ const ContextParts = Object.freeze({
             ContextParts.collectCloseError(error, errors);
         }
     },
-    async drainContextBuses(commandBus, eventBus) {
+    /**
+     * Waits until accepted command, event, System event, and signal work drains.
+     *
+     * @param commandBus Command bus.
+     * @param eventBus Domain event bus.
+     * @param systemEventBus System event bus.
+     * @param publisher Signal publisher.
+     * @returns Promise fulfilled when accepted work stabilizes.
+     */
+    async drainContextWork(commandBus, eventBus, systemEventBus, publisher) {
         let observedCommandWork = -1;
         let observedEventWork = -1;
+        let observedSystemEventWork = -1;
         do {
             observedCommandWork = commandBusAccess.acceptedWorkCount(commandBus);
             observedEventWork = eventBusAccess.acceptedWorkCount(eventBus);
+            observedSystemEventWork = eventBusAccess.acceptedWorkCount(systemEventBus);
             await commandBusAccess.drain(commandBus);
             await eventBusAccess.drain(eventBus);
+            await eventBusAccess.drain(systemEventBus);
+            await publisher.drain();
         } while (commandBusAccess.acceptedWorkCount(commandBus) !== observedCommandWork ||
-            eventBusAccess.acceptedWorkCount(eventBus) !== observedEventWork);
+            eventBusAccess.acceptedWorkCount(eventBus) !== observedEventWork ||
+            eventBusAccess.acceptedWorkCount(systemEventBus) !== observedSystemEventWork);
     },
+    /**
+     * Adds an error or aggregate causes to the close error collection.
+     *
+     * @param error Close failure.
+     * @param errors Failure collection.
+     */
     collectCloseError(error, errors) {
         if (error instanceof AggregateError) {
             const causes = error.errors;
@@ -1545,6 +2261,13 @@ const ContextParts = Object.freeze({
         }
         errors.push(error);
     },
+    /**
+     * Binds a repository to context runtime services and supplies commit and close operations.
+     *
+     * @param repository Repository to prepare.
+     * @param registration Context services and schemas.
+     * @returns Prepared repository.
+     */
     prepareRepositoryForContext(repository, registration) {
         ContextParts.requireRepositoryInstance(repository, "BoundedContext repository registration");
         const snapshot = ContextParts.repositorySnapshot(repository);
@@ -1556,14 +2279,9 @@ const ContextParts = Object.freeze({
             signalMetadata: new SignalMetadata(),
             entityInbox: registration.entityInbox,
             projectionInbox: registration.projectionInbox,
-            dispatchStored: registration.dispatchStored,
-            dispatchStoredFollowUp: registration.dispatchStoredFollowUp,
-            postEventFollowUp: registration.postEventFollowUp,
+            publisher: registration.publisher,
             registerEventSchema: registration.registerEventSchema,
             registerSystemEventSchema: registration.registerSystemEventSchema,
-            postSystemFollowUp: registration.postSystemFollowUp,
-            onPostCommand: registration.onPostCommand,
-            recordDispatchFailure: registration.recordDispatchFailure,
         });
         const entityInboxTarget = repositoryAccess.entityInboxTarget(repository);
         const projectionInboxTarget = repositoryAccess.projectionInboxTarget(repository);
@@ -1580,6 +2298,12 @@ const ContextParts = Object.freeze({
             },
         };
     },
+    /**
+     * Captures repository metadata needed for context registration.
+     *
+     * @param repository Repository to inspect.
+     * @returns Frozen registration snapshot.
+     */
     repositorySnapshot(repository) {
         const snapshot = repositoryAccess.snapshot(repository);
         return Object.freeze({
@@ -1592,6 +2316,11 @@ const ContextParts = Object.freeze({
             snapshot,
         });
     },
+    /**
+     * Rejects a repository already registered with a bounded context.
+     *
+     * @param repository Repository to check.
+     */
     rejectRegisteredRepository(repository) {
         const snapshot = ContextParts.repositorySnapshot(repository);
         const registration = registeredRepositories.get(repository);
@@ -1600,9 +2329,21 @@ const ContextParts = Object.freeze({
                 `"${registration.name.value}".`);
         }
     },
+    /**
+     * Creates storage record columns from Entity metadata.
+     *
+     * @param snapshot Registration snapshot supplying fields.
+     * @returns Record columns.
+     */
     repositoryColumns(snapshot) {
         return snapshot.metadata.columns.map((field) => new RecordColumn(field.name, ColumnTypes.fromField(field.descriptor), (record) => ContextParts.readRecordField(record, field.localName)));
     },
+    /**
+     * Creates an immutable repository view from a registration snapshot.
+     *
+     * @param snapshot Registration snapshot.
+     * @returns Immutable repository view.
+     */
     createRepositoryView(snapshot) {
         return Object.freeze({
             entityType: snapshot.entityType,
@@ -1614,35 +2355,12 @@ const ContextParts = Object.freeze({
             snapshot: snapshot.snapshot,
         });
     },
-    cloneDispatchFailure(failure) {
-        return Object.freeze({
-            event: clone(EventSchema, failure.event),
-            error: ContextParts.cloneDispatchError(failure.error),
-        });
-    },
-    snapshotDispatchError(error) {
-        if (error instanceof Error) {
-            const snapshot = {
-                name: ContextParts.boundedErrorString(error.name, dispatchErrorMessageLimit) || "Error",
-                message: ContextParts.boundedErrorString(error.message, dispatchErrorMessageLimit),
-                ...(typeof error.stack === "string"
-                    ? { stack: ContextParts.boundedErrorString(error.stack, dispatchErrorStackLimit) }
-                    : {}),
-            };
-            return Object.freeze(snapshot);
-        }
-        return Object.freeze({
-            name: "NonErrorThrow",
-            message: ContextParts.boundedErrorString(String(error), dispatchErrorMessageLimit),
-        });
-    },
-    cloneDispatchError(error) {
-        return Object.freeze({
-            name: error.name,
-            message: error.message,
-            ...(error.stack === undefined ? {} : { stack: error.stack }),
-        });
-    },
+    /**
+     * Builds dispatch descriptors for Projection repositories with event handlers.
+     *
+     * @param repositories Repository views to inspect.
+     * @returns Frozen Projection dispatch descriptors.
+     */
     projectionDispatchers(repositories) {
         const projections = [];
         for (const repository of repositories) {
@@ -1661,6 +2379,12 @@ const ContextParts = Object.freeze({
         }
         return Object.freeze(projections);
     },
+    /**
+     * Collects unique Projection state schemas for clearing.
+     *
+     * @param projections Projection dispatch descriptors.
+     * @returns Frozen unique clear targets.
+     */
     projectionStateClearTargets(projections) {
         const unique = new Map();
         for (const projection of projections) {
@@ -1673,6 +2397,13 @@ const ContextParts = Object.freeze({
         }
         return Object.freeze([...unique.values()]);
     },
+    /**
+     * Reads stored events in deterministic timestamp, producer, version, and ID order.
+     *
+     * @param context Event-store storage context.
+     * @param storageFactory Event storage provider.
+     * @returns Stored events in deterministic order.
+     */
     async readStoredEvents(context, storageFactory) {
         const eventStore = new EventStore(context, storageFactory);
         try {
@@ -1689,12 +2420,24 @@ const ContextParts = Object.freeze({
             eventStore.close();
         }
     },
+    /**
+     * Builds Stand options for the catch-up tenant scope.
+     *
+     * @param context Catch-up storage context.
+     * @returns Options with a cloned tenant ID when multitenant.
+     */
     catchUpStandOptions(context) {
         if (!context.multitenant) {
             return {};
         }
         return Object.freeze({ tenantId: clone(TenantIdSchema, context.tenantId) });
     },
+    /**
+     * Verifies a stored event envelope belongs to the catch-up tenant.
+     *
+     * @param context Catch-up storage context.
+     * @param event Stored event to validate.
+     */
     validateReplayTenant(context, event) {
         if (!context.multitenant) {
             return;
@@ -1708,6 +2451,12 @@ const ContextParts = Object.freeze({
             throw new Error("Read-side catch-up stored event envelope tenant does not match.");
         }
     },
+    /**
+     * Reads the tenant ID from an event import or past-message origin.
+     *
+     * @param event Event whose origin is inspected.
+     * @returns Cloned tenant ID when present.
+     */
     readReplayTenant(event) {
         switch (event.context?.origin.case) {
             case "importContext":
@@ -1718,9 +2467,23 @@ const ContextParts = Object.freeze({
                 return undefined;
         }
     },
+    /**
+     * Copies a tenant ID when present.
+     *
+     * @param tenantId Optional tenant ID.
+     * @returns Cloned tenant ID or undefined.
+     */
     tenantIdValue(tenantId) {
         return tenantId === undefined ? undefined : clone(TenantIdSchema, tenantId);
     },
+    /**
+     * Dispatches a stored event to matching Projection handlers and direct updates.
+     *
+     * @param projections Projection dispatch descriptors.
+     * @param event Stored event.
+     * @param rebuild Whether direct dispatch is a rebuild.
+     * @returns One when a Projection matched, otherwise zero.
+     */
     async dispatchStoredProjectionEvent(projections, event, rebuild) {
         const typeUrl = event.message?.typeUrl;
         if (typeUrl === undefined || typeUrl === "") {
@@ -1735,24 +2498,51 @@ const ContextParts = Object.freeze({
         }
         return matching.length > 0 ? 1 : 0;
     },
+    /**
+     * Creates a replay error with the event ID and bounded cause details.
+     *
+     * @param event Event that failed.
+     * @param cause Thrown replay cause.
+     * @returns Replay error.
+     */
     catchUpReplayError(event, cause) {
         return new CatchUpReplayError(event.id?.value ?? "(missing)", ContextParts.catchUpReplayDetail(cause));
     },
+    /**
+     * Returns an error string truncated to a maximum length.
+     *
+     * @param value String to bound.
+     * @param limit Maximum character count.
+     * @returns Bounded string.
+     */
     boundedErrorString(value, limit) {
         return value.length <= limit ? value : `${value.slice(0, limit - 3)}...`;
     },
+    /**
+     * Converts a thrown value to bounded error name and message details.
+     *
+     * @param error Thrown value.
+     * @returns Immutable bounded details.
+     */
     catchUpReplayDetail(error) {
         if (error instanceof Error) {
             return Object.freeze({
-                name: ContextParts.boundedErrorString(error.name, dispatchErrorMessageLimit) || "Error",
-                message: ContextParts.boundedErrorString(error.message, dispatchErrorMessageLimit),
+                name: ContextParts.boundedErrorString(error.name, errorDetailLimit) || "Error",
+                message: ContextParts.boundedErrorString(error.message, errorDetailLimit),
             });
         }
         return Object.freeze({
             name: "NonErrorThrow",
-            message: ContextParts.boundedErrorString(String(error), dispatchErrorMessageLimit),
+            message: ContextParts.boundedErrorString(String(error), errorDetailLimit),
         });
     },
+    /**
+     * Reads and requires the Entity ID field from a stored record.
+     *
+     * @param record Protobuf record.
+     * @param snapshot Repository metadata identifying the ID field.
+     * @returns ID field value; throws when missing.
+     */
     readRecordId(record, snapshot) {
         const value = ContextParts.readRecordField(record, snapshot.idField.localName);
         if (value === undefined || value === null) {
@@ -1760,6 +2550,13 @@ const ContextParts = Object.freeze({
         }
         return value;
     },
+    /**
+     * Reads a field from a Protobuf record by descriptor local name.
+     *
+     * @param record Record message.
+     * @param localName Descriptor local field name.
+     * @returns Field value.
+     */
     readRecordField(record, localName) {
         return record[localName];
     },