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

package/dist/context/bounded-context.js

@@ -20,36 +20,28 @@ import { freezeRegistry, isAiModel, registryOptions } from "@spine-event-engine/
 import { TypeUrls } from "@spine-event-engine/core";
 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, StorageGroup, } from "@spine-event-engine/storage";
-import { AgentExecutionStorageFactories, AgentHistoryStorageFactories, TenantBoundary, } from "@spine-event-engine/storage/provider";
-/**
- * Storage family shared by paired System Event publication and trusted reads.
- * @internal
- */
-export const systemEventGroup = new StorageGroup("spine_system_events");
+import { ColumnTypes, EventStore, RecordColumn, } from "@spine-event-engine/storage";
+import { AgentHistoryStorageFactories, EventStoreGroups, eventStoreRecordSpec, StoragePreparations, TenantBoundary, } from "@spine-event-engine/storage/provider";
 import { CommandBus, commandBusAccess } from "../bus/command-bus.js";
 import { EventBus, eventBusAccess, isSystemEventSchema, } from "../bus/event-bus.js";
-import { DeliveryReadiness, } from "./local-inbox-handoff.js";
+import { DeliveryReadiness } from "./local-inbox-handoff.js";
 import { LocalEntityInbox } from "./entity-inbox.js";
 import { LocalProjectionInbox } from "./projection-handoff.js";
-import { TenantIndexes } from "./tenant-index.js";
-import { EffectiveTenants } from "./effective-tenant.js";
-import { AgentScheduler } from "../agent/agent-scheduler.js";
-import { AgentExecutionCapacity } from "../agent/agent-execution-capacity.js";
+import { TenantAdmissions } from "./tenant-unknown-error.js";
+import { AgentExecutionCapacity, } from "../agent/agent-execution-capacity.js";
+import { AgentAcceptanceReceipts, agentAcceptanceReceiptGroup, agentAcceptanceReceiptSpec, } from "../agent/agent-acceptance-receipts.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";
+import { runtimeAccess } from "../runtime/runtime.js";
+import { Stand, standAccess } from "../stand/stand.js";
 import { SubscriptionRuntime, subscriptionRuntimeAccess } from "../stand/subscription-runtime.js";
-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 { StorageSubscriptionRegistry, subscriptionRecordSpec, } from "../stand/subscription-registry.js";
 import { IntegrationBroker } from "../integration/integration-broker.js";
-import { ServerEnvironment } from "../server/server-environment.js";
+import { ServerEnvironment, serverEnvironmentAccess } from "../server/server-environment.js";
 import { SignalPublisher } from "../runtime/signal-publisher.js";
 import { StandaloneHandlerRuntime, } from "../runtime/standalone-handler-runtime.js";
 /**
@@ -73,6 +65,38 @@ export class BoundedContextNameError extends Error {
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
+/**
+ * Rejects an Entity state type already served by another open domain context.
+ */
+export class DuplicateEntityStateException extends Error {
+    // prettier-ignore
+    /**
+     * Wire type URL of the conflicting Entity state.
+     */
+    stateType;
+    /**
+     * Name of the context that already serves the state.
+     */
+    registeredContext;
+    /**
+     * Name of the context attempting registration.
+     */
+    conflictingContext;
+    /**
+     * Creates a duplicate-state registration error.
+     * @param stateType Entity state wire type URL.
+     * @param registeredContext Existing domain context name.
+     * @param conflictingContext New domain context name.
+     */
+    constructor(stateType, registeredContext, conflictingContext) {
+        super(`Entity state "${stateType}" is already registered in "${registeredContext}"; ` +
+            `register it in only one open domain Bounded Context (attempted in "${conflictingContext}").`);
+        this.name = "DuplicateEntityStateException";
+        this.stateType = stateType;
+        this.registeredContext = registeredContext;
+        this.conflictingContext = conflictingContext;
+    }
+}
 const frameworkConstructionToken = Object.freeze({
     frameworkConstructionToken: true,
 });
@@ -87,6 +111,8 @@ const contextTenantIndexes = new WeakMap();
 const contextStorageFactories = new WeakMap();
 const contextDeliveryDescriptors = new WeakMap();
 const contextSubscriptionRuntimes = new WeakMap();
+const contextPreparations = new WeakMap();
+const contextInputPreparations = new WeakMap();
 const contextLoggers = new WeakMap();
 const contextSignalPublishers = new WeakMap();
 const contextEventBuses = new WeakMap();
@@ -97,7 +123,9 @@ const contextClosePhases = new WeakMap();
 const contextIntegrations = new WeakMap();
 const systemEventPosters = new WeakMap();
 const builderBuilds = new WeakMap();
+const explicitPreparations = new WeakMap();
 let constructBoundedContext;
+let registerBoundedContext;
 let constructBoundedContextBuilder;
 let constructContextSpec;
 /**
@@ -113,22 +141,37 @@ export class BoundedContext {
     #eventEndpoint;
     #entityInbox;
     #projectionInbox;
-    #deliveryStrategy;
+    #deliveryReadiness;
+    #stopAgentAvailability;
     #registeredRepositories = [];
     #repositoryViews = new Set();
     #storageFactory;
+    #environment;
     #ai;
     #stand;
     #systemStand;
     #subscriptionRuntime;
-    #agentScheduler;
-    #agentErrors = [];
+    /**
+     * Explicit storage and subscription preparation for this built context.
+     */
+    runtime;
+    #agentReceipts;
+    #agentController = new AbortController();
+    #agentReservations = new Set();
+    #activeReplays = new Set();
+    #activePreparations = new Set();
+    #tenantPreparations = new Map();
+    #preparationController = new AbortController();
+    #sharedPreparation;
     #closed;
     /**
      * Registers the framework-only construction hook for this module.
      */
     static {
         constructBoundedContext = (input) => new BoundedContext(input);
+        registerBoundedContext = (context, repositories) => {
+            context.#registerRepositories(repositories);
+        };
     }
     /**
      * Creates a Bounded Context from its prepared framework services.
@@ -145,9 +188,12 @@ export class BoundedContext {
         this.#stand = input.stand;
         this.#systemStand = input.systemStand;
         this.#subscriptionRuntime = input.subscriptionRuntime;
+        this.runtime = this.#createRuntime();
         this.#storageFactory = input.storageFactory;
+        this.#agentReceipts = new AgentAcceptanceReceipts(input.storageFactory);
+        this.#environment = ServerEnvironment.instance();
         this.#ai = input.ai;
-        this.#deliveryStrategy = ContextParts.snapshotDeliveryStrategy(input.deliveryStrategy);
+        this.#installTenantAdmission();
         this.#commandEndpoint = Object.freeze({
             acceptedCommandTypes: () => this.#commandBus.acceptedCommandTypes(),
             post: (command) => this.#commandBus.post(command),
@@ -156,79 +202,304 @@ export class BoundedContext {
             acceptedEventTypes: () => ContextParts.exposedEventTypeUrls(this.#eventBus),
             post: (event) => ContextParts.postContextEvent(this, event),
         });
-        const delivery = this.#createDelivery(input.storageFactory);
+        const delivery = this.#createDelivery(input.tenantIndex);
+        this.#deliveryReadiness = delivery.deliveryReadiness;
         this.#entityInbox = delivery.entityInbox;
         this.#projectionInbox = delivery.projectionInbox;
         this.#installReferences(input, delivery);
-        this.#registerAndStart(input.repositories, delivery.tenantIndex);
-        this.#startAgentScheduler(delivery.tenantIndex);
+        serverEnvironmentAccess.addContext(this.#environment, this);
         Object.freeze(this);
     }
     /**
-     * Starts bounded indexed discovery for registered Agent repositories.
+     * Exposes explicit preparation for this built context.
+     *
+     * @returns Stable explicit preparation methods.
      */
-    #startAgentScheduler(tenantIndex) {
-        if (this.#ai === undefined)
-            return;
-        const repositories = [...this.#repositoryViews].filter((entry) => entry.entityFamily === "agent");
-        if (repositories.length === 0)
-            return;
-        this.#agentScheduler = new AgentScheduler({
-            repositories: repositories.length,
-            page: (after, signal) => tenantIndex.page({
-                count: 16,
-                signal,
-                ...(after === undefined ? {} : { after }),
-            }),
-            scope: (id, index) => {
-                const repository = repositories[index];
-                if (repository === undefined)
-                    throw new Error("Agent repository scope is unavailable.");
-                return this.#agentScope(repository, tenantIndex.tenantMode === "single-tenant" ? undefined : id);
-            },
-        }, AgentExecutionCapacity.for(this.#ai), (error) => {
-            if (this.#agentErrors.length < 32)
-                this.#agentErrors.push(error);
+    #createRuntime() {
+        return Object.freeze({
+            createStorageStructures: (...ids) => this.#explicitStructures("create", ids),
+            checkStructureCompatibility: (...ids) => this.#explicitStructures("check", ids),
+            startSubscriptionMonitoring: () => this.#explicitMonitoring(),
         });
-        this.#agentScheduler.start();
     }
     /**
-     * Builds one scan scope from an accepted handoff or a catalog sweep.
+     * Installs live membership checks on context signal buses.
      *
-     * @param repository Registered Agent repository.
-     * @param tenantId Accepted tenant, absent only in a single-tenant Bounded Context.
-     * @returns The matching indexed provider scan scope.
      */
-    #agentScope(repository, tenantId) {
-        const effective = EffectiveTenants.current(this.#snapshot.tenantMode === "multitenant", tenantId);
+    #installTenantAdmission() {
+        explicitPreparations.set(this, (mode, ids) => this.#prepareExplicitLocal(mode, ids));
+        commandBusAccess.bindEnvironment(this.#commandBus, this.#environment);
+        eventBusAccess.bindEnvironment(this.#eventBus, this.#environment);
+        eventBusAccess.bindEnvironment(this.#systemEventBus, this.#environment);
+        commandBusAccess.setAdmission(this.#commandBus, (command) => this.#admitTenant(command.context?.actorContext?.tenantId));
+        eventBusAccess.setAdmission(this.#eventBus, (event) => this.#admitTenant(ContextParts.readReplayTenant(event)));
+        standAccess.setAdmission(this.#stand, (tenantId) => this.#admitTenant(tenantId));
+        standAccess.setPublicAdmission(this.#stand, () => {
+            if (closingContexts.has(this) && !runtimeAccess.isRunningAdmittedWork(this.#environment))
+                throw new Error("Bounded Context is closing.");
+        });
+    }
+    /**
+     * Checks this context's live index before repository work.
+     *
+     * @param tenantId Captured tenant identity, when applicable.
+     */
+    async #admitTenant(tenantId) {
+        await TenantAdmissions.require(this.tenantIndex, this.#snapshot.name.value, this.isMultitenant, tenantId);
+        await this.#prepareInput(tenantId);
+    }
+    /**
+     * Initializes only the admitted input's complete context and tenant requirements.
+     * @param tenantId Captured input tenant identity, when applicable.
+     * @returns Completion after storage and first monitoring pass are ready.
+     */
+    async #prepareInput(tenantId) {
+        await this.#prepareShared("create");
+        await this.#prepareTenant(tenantId, "create");
+        if (!closingContexts.has(this))
+            await this.#subscriptionRuntime.start();
+    }
+    /**
+     * Prepares the fixed shared subscription registry layout once per context.
+     * @param mode Required provider preparation mode.
+     * @returns Shared preparation completion.
+     */
+    #prepareShared(mode) {
+        if (!(this.#subscriptionRuntime.registry() instanceof StorageSubscriptionRegistry))
+            return Promise.resolve();
+        if (this.#sharedPreparation !== undefined)
+            return this.#sharedPreparation;
+        const attempt = this.#trackPreparation(() => StoragePreparations.for(this.#storageFactory).prepareRecord(ContextParts.createSubscriptionStorageContext(this.#snapshot.spec), subscriptionRecordSpec, undefined, mode));
+        this.#sharedPreparation = attempt;
+        void attempt.catch(() => {
+            if (this.#sharedPreparation === attempt)
+                this.#sharedPreparation = undefined;
+        });
+        return attempt;
+    }
+    /**
+     * Shares one pending complete-tenant preparation without caching a stale model flag.
+     * @param tenantId Captured tenant identity, when applicable.
+     * @param mode Required provider preparation mode.
+     * @returns Complete tenant preparation attempt.
+     */
+    #prepareTenant(tenantId, mode) {
+        const context = this.#storageContextFor(tenantId);
+        const key = TenantBoundary.of(context).key;
+        const pending = this.#tenantPreparations.get(key);
+        if (pending !== undefined)
+            return pending;
+        const attempt = this.#trackPreparation(() => this.#prepareTenantNow(context, mode));
+        this.#tenantPreparations.set(key, attempt);
+        void attempt.then(() => this.#tenantPreparations.delete(key), () => this.#tenantPreparations.delete(key));
+        return attempt;
+    }
+    /**
+     * Prepares exact Event, Entity and Agent families for one captured destination.
+     * @param context Captured physical storage destination.
+     * @param mode Required provider preparation mode.
+     * @returns Completion after all declared families are ready.
+     */
+    async #prepareTenantNow(context, mode) {
+        const preparation = StoragePreparations.for(this.#storageFactory);
+        await preparation.prepareRecord(context, eventStoreRecordSpec, EventStoreGroups.forContext(context.name), mode);
+        const system = ContextParts.requireSystemPairing(this).system;
+        if (system.storesEvents) {
+            const systemContext = { ...context, name: system.name.value };
+            await preparation.prepareRecord(systemContext, eventStoreRecordSpec, EventStoreGroups.forContext(system.name.value, "system"), mode);
+        }
+        for (const repository of this.#repositoryViews)
+            await repositoryAccess.prepareStorage(repository, context, this.#storageFactory, mode);
+        if ([...this.#repositoryViews].some((repository) => repository.entityFamily === "agent"))
+            await preparation.prepareRecord(context, agentAcceptanceReceiptSpec, agentAcceptanceReceiptGroup, mode);
+    }
+    /**
+     * Captures the same tenant scope used by repository and Event storage.
+     * @param tenantId Complete selected tenant identity, when applicable.
+     * @returns A detached provider storage context.
+     */
+    #storageContextFor(tenantId) {
+        if (!this.isMultitenant)
+            return { name: this.name.value, multitenant: false };
+        if (tenantId === undefined)
+            throw new Error("Multitenant preparation requires tenantId.");
         return {
-            id: JSON.stringify([
-                this.#snapshot.name.value,
-                String(TenantBoundary.from(effective).key),
-                repository.stateFullTypeName,
-            ]),
-            pending: (after, count) => repositoryAccess.pendingAcceptedAgents(repository, tenantId, after, count),
-            run: (key, signal) => repositoryAccess.runAcceptedAgent(repository, tenantId, key, signal),
+            name: this.name.value,
+            multitenant: true,
+            tenantId: TenantBoundary.from(tenantId).tenantId,
         };
     }
+    /**
+     * Retains an admitted preparation until closure can safely release its provider.
+     * @param onPrepare Complete provider preparation callback.
+     * @returns Tracked preparation completion.
+     */
+    #trackPreparation(onPrepare) {
+        const attempt = Promise.resolve().then(onPrepare);
+        this.#activePreparations.add(attempt);
+        void attempt.then(() => this.#activePreparations.delete(attempt), () => this.#activePreparations.delete(attempt));
+        return attempt;
+    }
+    /**
+     * Completes independently requested eager structure and monitor phases.
+     * @param options Independent build-time initialization choices.
+     * @returns Completion after requested phases settle.
+     */
+    async #prepareBuild(options) {
+        if (options.createStorageStructures !== false) {
+            await this.#requiredPrepare(() => this.#prepareShared("create"));
+            await this.#prepareCurrentTenants("create");
+        }
+        if (options.startSubscriptionMonitoring !== false) {
+            await this.#requiredPrepare(() => this.#prepareShared("create"));
+            await this.#requiredPrepare(() => this.#subscriptionRuntime.start());
+        }
+    }
+    /**
+     * Classifies a requested startup phase without changing shared lazy attempts.
+     * @param onPrepare Required provider or initial-monitor phase.
+     * @returns Completion of the requested phase.
+     */
+    async #requiredPrepare(onPrepare) {
+        serverEnvironmentAccess.requireAvailable(this.#environment);
+        try {
+            await onPrepare();
+        }
+        catch (error) {
+            serverEnvironmentAccess.failStartup(this.#environment, error);
+            throw error;
+        }
+        serverEnvironmentAccess.requireAvailable(this.#environment);
+    }
+    /**
+     * Traverses the current live index in finite pages without a tenant cap.
+     * @param mode Creation or read-only check.
+     * @returns Completion after currently listed tenants are prepared.
+     */
+    async #prepareCurrentTenants(mode) {
+        if (!this.isMultitenant)
+            return this.#requiredPrepare(() => this.#prepareTenant(undefined, mode));
+        let after;
+        do {
+            serverEnvironmentAccess.requireAvailable(this.#environment);
+            const page = await this.tenantIndex.page({
+                count: 64,
+                signal: this.#preparationController.signal,
+                ...(after === undefined ? {} : { after }),
+            });
+            serverEnvironmentAccess.requireAvailable(this.#environment);
+            for (const id of page.ids) {
+                serverEnvironmentAccess.requireAvailable(this.#environment);
+                await TenantAdmissions.require(this.tenantIndex, this.name.value, true, id);
+                serverEnvironmentAccess.requireAvailable(this.#environment);
+                await this.#requiredPrepare(() => this.#prepareTenant(id, mode));
+            }
+            after = page.hasMore ? page.after : undefined;
+        } while (after !== undefined);
+    }
+    /**
+     * Admits explicit structure work and joins fatal cleanup after local settlement.
+     * @param mode Creation or read-only compatibility mode.
+     * @param tenantIds Explicit complete tenant identities, if supplied.
+     * @returns Completion after the selected structures are ready.
+     */
+    async #explicitStructures(mode, tenantIds) {
+        const captured = tenantIds.map((id) => TenantBoundary.from(id).tenantId);
+        const admitted = boundedContextAccess.admitServiceRegistryOperation(this, () => this.#prepareExplicitLocal(mode, captured));
+        return this.#joinRequiredCleanup(admitted);
+    }
+    /**
+     * Runs explicit preparation while the caller holds this context's admission.
+     *
+     * @param mode Creation or read-only check.
+     * @param ids Captured tenant identities, when supplied.
+     * @returns Completion of the local preparation.
+     */
+    async #prepareExplicitLocal(mode, ids) {
+        const selected = await this.#selectedTenants(ids);
+        await this.#requiredPrepare(() => this.#prepareShared(mode));
+        if (selected === undefined)
+            return this.#prepareCurrentTenants(mode);
+        for (const id of selected) {
+            await TenantAdmissions.require(this.tenantIndex, this.name.value, this.isMultitenant, id);
+            await this.#requiredPrepare(() => this.#prepareTenant(id, mode));
+        }
+    }
+    /**
+     * Validates all explicit IDs before any provider preparation.
+     *
+     * @param ids Captured explicit tenant identities.
+     * @returns Distinct current IDs or undefined for all current tenants.
+     */
+    async #selectedTenants(ids) {
+        if (ids.length === 0)
+            return undefined;
+        const selected = new Map();
+        for (const id of ids) {
+            await TenantAdmissions.require(this.tenantIndex, this.name.value, this.isMultitenant, id);
+            const boundary = TenantBoundary.from(id);
+            selected.set(boundary.key, boundary.tenantId);
+        }
+        return [...selected.values()];
+    }
+    /**
+     * Starts the one initial monitor pass as an explicit required phase.
+     *
+     * @returns Completion after the initial pass.
+     */
+    #explicitMonitoring() {
+        const admitted = boundedContextAccess.admitServiceRegistryOperation(this, async () => {
+            await this.#requiredPrepare(() => this.#prepareShared("create"));
+            await this.#requiredPrepare(() => this.#subscriptionRuntime.start());
+        });
+        return this.#joinRequiredCleanup(admitted);
+    }
+    /**
+     * Waits for recorded fatal cleanup only after context admission settles.
+     *
+     * @param admitted Locally admitted operation.
+     * @returns Completion after local work or fatal cleanup.
+     */
+    async #joinRequiredCleanup(admitted) {
+        try {
+            await admitted;
+        }
+        catch (error) {
+            if (serverEnvironmentAccess.hasStartupFailure(this.#environment))
+                return serverEnvironmentAccess.awaitStartupFailure(this.#environment);
+            throw error;
+        }
+    }
     /**
      * Creates tenant-aware Inboxes and their shared readiness signal.
      *
-     * @param storageFactory Provider supplying the tenant catalog.
+     * @param tenantIndex Effective membership index for this context.
      * @returns Inboxes, tenant index, and readiness signal.
      */
-    #createDelivery(storageFactory) {
-        const deliveryReadiness = new DeliveryReadiness();
-        const tenantIndex = TenantIndexes.create({
-            contextName: this.#snapshot.name.value,
-            tenantMode: this.#snapshot.tenantMode,
-            storageFactory,
-        });
-        const keepTenant = (tenantId) => tenantIndex.keep(tenantId);
-        const entityInbox = new LocalEntityInbox(this.#snapshot.name.value, deliveryReadiness, keepTenant, this.#deliveryStrategy);
-        const projectionInbox = new LocalProjectionInbox(this.#snapshot.name.value, deliveryReadiness, keepTenant);
+    #createDelivery(tenantIndex) {
+        const deliveryReadiness = this.#createReadiness();
+        const onAdmit = (tenantId) => this.#admitTenant(tenantId);
+        const entityInbox = new LocalEntityInbox(this.#snapshot.name.value, deliveryReadiness, onAdmit, this.#environment.delivery.strategy);
+        const projectionInbox = new LocalProjectionInbox(this.#snapshot.name.value, deliveryReadiness, onAdmit);
+        deliveryReadiness.configureDirect((message, tenantId) => message.label === "UPDATE_SUBSCRIBER"
+            ? projectionInbox.replay(message, tenantId)
+            : entityInbox.replay(message, tenantId));
         return { deliveryReadiness, tenantIndex, entityInbox, projectionInbox };
     }
+    /**
+     * Creates readiness for the shared Delivery and this context's Agent capacity.
+     * @returns Shared readiness with the Agent capacity wake installed.
+     */
+    #createReadiness() {
+        const readiness = new DeliveryReadiness(undefined, serverEnvironmentAccess.coreDelivery(this.#environment), (shard) => {
+            serverEnvironmentAccess.notifyDelivery(this.#environment, shard);
+        }, serverEnvironmentAccess.remoteSupervised(this.#environment));
+        if (this.#ai !== undefined)
+            this.#stopAgentAvailability = AgentExecutionCapacity.for(this.#ai).onAvailable(() => {
+                readiness.retryDeferred();
+            });
+        return readiness;
+    }
     /**
      * Installs framework references used after context construction.
      *
@@ -244,35 +515,17 @@ export class BoundedContext {
         contextTenantIndexes.set(this, delivery.tenantIndex);
         contextStorageFactories.set(this, input.storageFactory);
         contextSubscriptionRuntimes.set(this, this.#subscriptionRuntime);
+        contextPreparations.set(this, (options) => this.#prepareBuild(options));
+        contextInputPreparations.set(this, (tenantId) => this.#prepareInput(tenantId));
         contextSignalPublishers.set(this, this.#publisher);
         contextClosePhases.set(this, {
             begin: () => {
                 this.#beginClose();
             },
             drain: () => this.#drainWork(),
+            trackReplay: (onReplay) => this.#trackReplay(onReplay),
         });
-        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();
-        }
-        catch (error) {
-            try {
-                ContextParts.cleanupFailedContext(this, tenantIndex);
-            }
-            catch (cleanupError) {
-                throw new AggregateError([error, cleanupError], "Bounded Context build failed, and tenant index cleanup also failed.");
-            }
-            throw error;
-        }
+        contextDeliveryDescriptors.set(this, ContextParts.createDeliveryDescriptor(this.#entityInbox, this.#projectionInbox));
     }
     #registerRepositories(repositories) {
         const preparedRepositories = this.#prepareRepositories(repositories);
@@ -280,6 +533,7 @@ export class BoundedContext {
             for (const preparedRepository of preparedRepositories) {
                 ContextParts.rejectRegisteredRepository(preparedRepository.repository);
             }
+            this.#reserveStates(preparedRepositories);
             for (const preparedRepository of preparedRepositories) {
                 this.#stand.register(preparedRepository.snapshot.stateSchema, {
                     columns: ContextParts.repositoryColumns(preparedRepository.snapshot),
@@ -299,6 +553,19 @@ export class BoundedContext {
             this.#failRegistration(error, preparedRepositories);
         }
     }
+    /**
+     * Reserves Entity state types before registration mutates delivery targets.
+     *
+     * @param repositories Prepared repositories for this context.
+     */
+    #reserveStates(repositories) {
+        for (const repository of repositories) {
+            const stateType = TypeUrls.derive(repository.snapshot.stateSchema);
+            const prior = serverEnvironmentAccess.reserveState(this.#environment, this, stateType);
+            if (prior !== undefined)
+                throw new DuplicateEntityStateException(stateType, prior.name.value, this.name.value);
+        }
+    }
     #prepareRepositories(repositories) {
         const registration = this.#repositoryRegistration();
         const preparedRepositories = [];
@@ -312,14 +579,28 @@ export class BoundedContext {
         }
         return preparedRepositories;
     }
+    /**
+     * Reserves shared-registry capacity before Agent receipt admission.
+     */
+    #reserveAgent(key, signal) {
+        const reservation = this.#ai === undefined
+            ? undefined
+            : AgentExecutionCapacity.for(this.#ai).reserve(key, signal);
+        if (reservation !== undefined) {
+            this.#agentReservations.add(reservation.completed);
+            void reservation.completed.then(() => this.#agentReservations.delete(reservation.completed), () => this.#agentReservations.delete(reservation.completed));
+        }
+        return reservation;
+    }
     /**
      * Builds callbacks shared by every repository prepared for this Bounded Context.
      */
     #repositoryRegistration() {
-        const registration = {
+        return {
             name: ContextParts.cloneName(this.#snapshot.name),
             storageContext: ContextParts.createStorageMode(this.#snapshot.spec),
             storageFactory: this.#storageFactory,
+            onAdmit: (tenantId) => this.#admitTenant(tenantId),
             ...(this.#ai === undefined ? {} : { ai: this.#ai }),
             stand: this.#stand,
             entityInbox: this.#entityInbox,
@@ -331,23 +612,38 @@ export class BoundedContext {
             registerSystemEventSchema: (schema) => {
                 eventBusAccess.registerSchemas(this.#systemEventBus, [schema]);
             },
-            publishAgentEvent: (event) => event.context?.rejection === undefined
-                ? this.#publisher.publishEvent(event)
-                : this.#publisher.publishRejectionEvent(event),
-            prepareSavedCommand: (command) => commandBusAccess.prepareSaved(this.#commandBus, command),
-            publishSavedCommand: (command, plan) => commandBusAccess.postSavedFollowUp(this.#commandBus, command, plan),
+            publishAgentEvent: (event) => this.#publishAgentEvent(event),
             publishAgentSystemEvent: (event) => this.#publisher.publishSystemEvent(event),
-            recordAcceptedSaved: (signal) => {
-                this.#publisher.recordAcceptedSaved(signal);
-            },
-            wakeAcceptedAgent: (repository, tenantId) => {
-                this.#agentScheduler?.wake(this.#agentScope(repository, tenantId));
+            agentReceipts: this.#agentReceipts,
+            agentSignal: this.#agentController.signal,
+            reserveAgent: (key, signal) => this.#reserveAgent(key, signal),
+            deferAgent: (message, tenantId) => {
+                this.#deferAgent(message, tenantId);
             },
         };
-        return registration;
+    }
+    /**
+     * Publishes an Agent event on its selected ordinary or rejection bus.
+     */
+    #publishAgentEvent(event) {
+        return event.context?.rejection === undefined
+            ? this.#publisher.publishEvent(event)
+            : this.#publisher.publishRejectionEvent(event);
+    }
+    /**
+     * Records a deferred Agent shard for the next available capacity slot.
+     */
+    #deferAgent(message, tenantId) {
+        this.#deliveryReadiness.defer({
+            label: message.label,
+            targetTypeUrl: message.inboxId.targetTypeUrl,
+            shard: message.shard,
+            ...(tenantId === undefined ? {} : { tenantId }),
+        });
     }
     #failRegistration(error, preparedRepositories) {
-        const closeErrors = ContextParts.closePreparedRepositories(preparedRepositories);
+        const uncommitted = preparedRepositories.filter(({ repository }) => !this.#repositoryViews.has(repository));
+        const closeErrors = ContextParts.closePreparedRepositories(uncommitted);
         if (closeErrors.length > 0) {
             throw new AggregateError([error, ...closeErrors], "Repository registration failed, and prepared repository storage cleanup also failed.");
         }
@@ -395,6 +691,14 @@ export class BoundedContext {
     get isMultitenant() {
         return this.#snapshot.tenantMode === "multitenant";
     }
+    /**
+     * Returns the live index configured for this Bounded Context.
+     *
+     * @returns The effective configured index.
+     */
+    get tenantIndex() {
+        return ContextParts.requireTenantIndex(this);
+    }
     /**
      * Returns a copy-safe specification used to build this context.
      *
@@ -539,7 +843,9 @@ export class BoundedContext {
      */
     #beginClose() {
         closingContexts.add(this);
-        this.#agentScheduler?.stop();
+        this.#preparationController.abort(new Error("Bounded Context closed."));
+        serverEnvironmentAccess.stopRecipients(this.#environment, this);
+        this.#agentController.abort(new Error("Bounded Context closed."));
         this.#publisher.beginClose();
         commandBusAccess.beginClose(this.#commandBus);
         eventBusAccess.beginClose(this.#eventBus);
@@ -565,22 +871,35 @@ export class BoundedContext {
      */
     async #closeOnce() {
         const errors = [];
-        await this.#closePart(() => this.#agentScheduler?.close(), errors);
+        this.#stopAgentAvailability?.();
+        this.#stopAgentAvailability = undefined;
         await this.#closePart(() => this.#drainWork(), errors);
+        await this.#drainAdmittedContextWork(errors);
+        await this.#closePart(() => this.#deliveryReadiness.close(), errors);
+        await this.#closePart(() => ContextParts.drainContextWork(this.#commandBus, this.#eventBus, this.#systemEventBus, this.#publisher), errors);
+        await this.#closePart(() => this.#agentReceipts.close(), errors);
         await this.#closeBuses(errors);
         await this.#closePart(() => this.#stand.close(), errors);
         await this.#closePart(() => this.#systemStand.close(), errors);
         await this.#closePart(() => this.#subscriptionRuntime.finishClose(), errors);
-        await this.#closePart(() => {
-            ContextParts.requireTenantIndex(this).close();
-        }, errors);
         await this.#closeRepositories(errors);
+        serverEnvironmentAccess.removeContext(this.#environment, this);
         if (errors.length > 0) {
             this.#closed = undefined;
             throw new AggregateError(ContextParts.flattenErrors(errors), "BoundedContext close failed.");
         }
         ContextParts.clearContextMetadata(this);
     }
+    /**
+     * Settles entered replay, local follow-ups, and reserved Agent turns.
+     * @param errors Collects independent close failures.
+     */
+    async #drainAdmittedContextWork(errors) {
+        await this.#closePart(() => Promise.allSettled([...this.#activePreparations]).then(() => undefined), errors);
+        await this.#closePart(() => Promise.allSettled([...this.#activeReplays]).then(() => undefined), errors);
+        await this.#closePart(() => this.#entityInbox.whenFollowUpsIdle(), errors);
+        await this.#closePart(() => Promise.allSettled([...this.#agentReservations]).then(() => undefined), errors);
+    }
     /**
      * Closes bus intake and subscription drains before the Stands.
      *
@@ -602,13 +921,27 @@ export class BoundedContext {
      * @param errors Failures collected during context closure.
      */
     async #closeRepositories(errors) {
-        for (const repository of this.#repositoryViews) {
-            await this.#closePart(() => {
-                repositoryAccess.clearRuntime(repository);
+        const closing = [...this.#repositoryViews].map((repository) => {
+            return repositoryAccess.clearRuntime(repository).finally(() => {
                 registeredRepositories.delete(repository);
-            }, errors);
+            });
+        });
+        for (const result of await Promise.allSettled(closing)) {
+            if (result.status === "rejected")
+                errors.push(result.reason);
         }
     }
+    /**
+     * Registers an entered shared replay through its complete follow-up callback.
+     * @param onReplay Complete replay callback.
+     * @returns Completion of the captured callback.
+     */
+    #trackReplay(onReplay) {
+        const replay = Promise.resolve().then(onReplay);
+        this.#activeReplays.add(replay);
+        void replay.then(() => this.#activeReplays.delete(replay), () => this.#activeReplays.delete(replay));
+        return replay;
+    }
     /**
      * Calls a close action and collects its failure before later cleanup.
      * @param work Close action.
@@ -622,6 +955,70 @@ export class BoundedContext {
  * Exposes framework-only operations for built contexts and their builders.
  */
 export const boundedContextAccess = Object.freeze({
+    /**
+     * Reports whether close has started for the given context.
+     *
+     * @param context Completed context.
+     * @returns Whether close has started.
+     */
+    isClosing: (context) => closingContexts.has(context),
+    /**
+     * Prepares an admitted context without joining global fatal cleanup.
+     *
+     * @param context Admitted context.
+     * @param mode Creation or read-only check.
+     * @param ids Captured tenant identities.
+     * @returns Completion of local preparation.
+     */
+    prepareExplicit(context, mode, ids) {
+        const prepare = explicitPreparations.get(context);
+        if (prepare === undefined)
+            return Promise.reject(new TypeError("Preparation requires a built context."));
+        return prepare(mode, ids);
+    },
+    /**
+     * Admits a service membership and preparation chain before its first await.
+     *
+     * @param context Selected built context.
+     * @param tenantId Captured tenant identity, when applicable.
+     * @param onMembership Checks live tenant membership.
+     * @param onReady Performs the admitted one-shot registry mutation, if present.
+     * @returns Tracked completion of membership and model preparation.
+     */
+    admitServiceInput(context, tenantId, onMembership, onReady) {
+        if (closingContexts.has(context))
+            return Promise.reject(new Error("Bounded Context is closing."));
+        const prepare = contextInputPreparations.get(context);
+        const phase = contextClosePhases.get(context);
+        if (prepare === undefined || phase === undefined)
+            return Promise.reject(new TypeError("Service input requires a built context."));
+        return phase.trackReplay(async () => {
+            await onMembership();
+            await prepare(tenantId);
+            await onReady?.();
+        });
+    },
+    /**
+     * Admits one shared subscription-registry operation before asynchronous lookup.
+     *
+     * @param context Selected built context.
+     * @param onOperation Complete registry operation.
+     * @returns Tracked operation completion.
+     */
+    admitServiceRegistryOperation(context, onOperation) {
+        if (closingContexts.has(context))
+            return Promise.reject(new Error("Bounded Context is closing."));
+        const phase = contextClosePhases.get(context);
+        if (phase === undefined)
+            return Promise.reject(new TypeError("Service registry requires a built context."));
+        return phase.trackReplay(onOperation);
+    },
+    trackReplay(context, onReplay) {
+        const phase = contextClosePhases.get(context);
+        if (phase === undefined)
+            return Promise.reject(new TypeError("Replay requires a built context."));
+        return phase.trackReplay(onReplay);
+    },
     /**
      * Resolves a view only within the Bounded Context that issued it.
      *
@@ -669,7 +1066,7 @@ export const boundedContextAccess = Object.freeze({
         if (runtime === undefined) {
             throw new TypeError("Context logger requires a built BoundedContext instance.");
         }
-        subscriptionRuntimeAccess.installLogger(runtime, logger);
+        subscriptionRuntimeAccess.installLogger(runtime, logger, context.name.value);
     },
     loggerFor(context) {
         const logger = contextLoggers.get(context);
@@ -683,12 +1080,12 @@ export const boundedContextAccess = Object.freeze({
             value !== null &&
             builderBuilds.has(value));
     },
-    build(builder, defaultStorageFactory, defaultAi) {
+    build(builder) {
         const build = builderBuilds.get(builder);
         if (build === undefined) {
             throw new TypeError("Builder access requires a BoundedContextBuilder instance.");
         }
-        return build(defaultStorageFactory, defaultAi);
+        return build();
     },
     subscribeToEvent(context, typeUrl, subscriber) {
         const subscribe = eventSubscribers.get(context);
@@ -765,9 +1162,8 @@ export class BoundedContextBuilder {
     #repositories = new Set();
     #entityTypes = new Set();
     #generatedRepositoryOptions = new Map();
-    #deliveryStrategy = UniformAcrossAllShards.singleShard();
-    #storageFactory;
     #aiRegistry;
+    #tenantIndex;
     #subscriptionRegistry;
     #persistSystemEvents = false;
     #generatedRegistryRoot;
@@ -786,7 +1182,7 @@ export class BoundedContextBuilder {
     constructor(specSnapshot, token) {
         ContextParts.requireFrameworkConstructionToken(token, "BoundedContextBuilder instances are framework-owned.");
         this.#specSnapshot = ContextParts.cloneSpecSnapshot(specSnapshot);
-        builderBuilds.set(this, (defaultStorageFactory, defaultAi) => this.#buildAsyncWith(defaultStorageFactory, defaultAi));
+        builderBuilds.set(this, () => this.#buildAsyncWith());
         Object.freeze(this);
     }
     /**
@@ -861,7 +1257,7 @@ export class BoundedContextBuilder {
      *
      * @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
+     *   this builder's `build()` path. It installs its Command and Event sides
      *   exactly once.
      *
      * @returns This builder for further configuration.
@@ -888,7 +1284,7 @@ export class BoundedContextBuilder {
      * Adds an event dispatcher to the context being built.
      *
      * @param dispatcher Raw event dispatcher, or a standalone reactor/subscriber.
-     *   Standalone receivers require generated receiver metadata and `buildAsync()`.
+     *   Standalone receivers require generated receiver metadata and `build()`.
      *
      * @returns This builder for further configuration.
      */
@@ -905,7 +1301,7 @@ export class BoundedContextBuilder {
      * Adds a generated standalone command assignee.
      *
      * The registered instance is matched by exact constructor to generated
-     * receiver metadata when `buildAsync()` assembles the context.
+     * receiver metadata when `build()` assembles the context.
      *
      * @param assignee Generated standalone assignee instance.
      * @returns This builder for further configuration.
@@ -925,13 +1321,13 @@ export class BoundedContextBuilder {
         return this;
     }
     /**
-     * Sets a storage factory for event, repository-state, and Stand storage.
+     * Sets a live tenant index for this Bounded Context.
      *
-     * @param storageFactory Creates the context's persistent storage.
-     * @returns Returns this builder for further configuration.
+     * @param tenantIndex Application membership index.
+     * @returns This builder.
      */
-    withStorageFactory(storageFactory) {
-        this.#storageFactory = storageFactory;
+    withTenantIndex(tenantIndex) {
+        this.#tenantIndex = tenantIndex;
         return this;
     }
     /**
@@ -969,16 +1365,6 @@ export class BoundedContextBuilder {
         this.#subscriptionRegistry = registry;
         return this;
     }
-    /**
-     * 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.
-     */
-    withDeliveryStrategy(strategy) {
-        this.#deliveryStrategy = ContextParts.snapshotDeliveryStrategy(strategy);
-        return this;
-    }
     /**
      * Sets a trusted compiled application root for generated handler metadata.
      *
@@ -990,49 +1376,108 @@ export class BoundedContextBuilder {
         return this;
     }
     /**
-     * Builds a context from explicitly added repositories and dispatchers.
+     * Builds a context after loading generated handlers and preparing runtime resources.
      *
-     * @returns Returns the built context.
+     * @param options Independent eager structure and subscription timing choices.
+     * @returns The built context after requested initialization and integration are ready.
      */
-    build() {
-        if (this.#standaloneInstances().length > 0) {
-            throw new Error("Standalone generated handlers require buildAsync().");
+    build(options = {}) {
+        return this.#buildAsyncWith(options);
+    }
+    async #buildAsyncWith(options = {}) {
+        const environment = ServerEnvironment.instance();
+        const finishBuild = serverEnvironmentAccess.beginContextBuild(environment);
+        let built;
+        let failed = false;
+        let failure;
+        try {
+            await serverEnvironmentAccess.awaitSetup(environment);
+            built = await this.#buildAsyncReady(options, environment);
+        }
+        catch (error) {
+            failed = true;
+            failure = error;
+        }
+        finally {
+            finishBuild();
         }
-        ContextParts.rejectSyncEntityAssembly(this.#entityTypes);
-        return this.#buildWith([...this.#repositories], this.#storageFactory ?? new InMemoryStorageFactory(), [], this.#aiRegistry);
+        if (serverEnvironmentAccess.hasStartupFailure(environment))
+            return serverEnvironmentAccess.awaitStartupFailure(environment);
+        if (failed)
+            throw failure;
+        if (built === undefined)
+            throw new Error("Bounded Context build did not complete.");
+        return built;
     }
     /**
-     * Builds a context after loading generated metadata for added entity classes
-     * and registered standalone handlers.
+     * Loads generated metadata and finishes one asynchronous context assembly.
      *
-     * 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.
+     * @returns The integrated context.
      */
-    async buildAsync() {
-        return this.#buildAsyncWith();
-    }
-    async #buildAsyncWith(defaultStorageFactory, defaultAi) {
+    async #buildAsyncReady(options, environment) {
         const generated = await this.#loadGeneratedArtifacts([...this.#entityTypes]);
+        serverEnvironmentAccess.requireAvailable(environment);
         const repositories = [...this.#repositories, ...generated.repositories];
-        const context = this.#buildWith(repositories, this.#storageFactory ?? defaultStorageFactory ?? new InMemoryStorageFactory(), generated.standalone, this.#aiRegistry ?? defaultAi);
+        const context = await this.#buildWithResources(repositories, environment.storageFactory, generated.standalone, this.#aiRegistry ?? environment.ai);
         try {
-            await ContextParts.integrationReady(context);
+            await this.#integrateBuiltContext(context, options, environment);
         }
         catch (error) {
-            try {
-                await context.close();
-            }
-            catch (closeError) {
-                throw new AggregateError([error, closeError], "BoundedContext broker open failed during cleanup.");
-            }
-            throw error;
+            return this.#closeFailedBuild(context, environment, error);
         }
         return context;
     }
-    #buildWith(repositories, storageFactory, standalone = [], ai) {
+    /**
+     * Completes required integration and requested initialization before publication.
+     * @param context Constructed context.
+     * @param options Requested eager initialization phases.
+     * @param environment Captured environment lifetime.
+     */
+    async #integrateBuiltContext(context, options, environment) {
+        serverEnvironmentAccess.requireAvailable(environment);
+        boundedContextAccess.installLogger(context, serverEnvironmentAccess.loggerFor(environment));
+        await ContextParts.integrationReady(context).catch((error) => {
+            serverEnvironmentAccess.failStartup(environment, error);
+            throw error;
+        });
+        serverEnvironmentAccess.requireAvailable(environment);
+        const prepare = contextPreparations.get(context);
+        if (prepare === undefined)
+            throw new Error("Context preparation is unavailable.");
+        await prepare(options);
+        serverEnvironmentAccess.requireAvailable(environment);
+        await serverEnvironmentAccess.completeContext(environment, context);
+    }
+    /**
+     * Releases a failed partial context before its build ticket settles.
+     * @param context Context assembled before the failure.
+     * @param environment Captured environment lifetime.
+     * @param error Original build failure.
+     * @returns Rejection retaining the original and any local cleanup failure.
+     */
+    async #closeFailedBuild(context, environment, error) {
+        try {
+            await context.close();
+        }
+        catch (closeError) {
+            if (serverEnvironmentAccess.hasStartupFailure(environment)) {
+                serverEnvironmentAccess.recordStartupCleanup(environment, closeError);
+                throw error;
+            }
+            throw new AggregateError([error, closeError], "BoundedContext open cleanup failed.");
+        }
+        throw error;
+    }
+    /**
+     * Assembles a context and cleans partial resources on failure.
+     *
+     * @param repositories Repositories selected for the context.
+     * @param storageFactory Storage factory for the context.
+     * @param standalone Generated standalone handler groups.
+     * @param ai Optional AI registry.
+     * @returns The assembled context.
+     */
+    async #buildWithResources(repositories, storageFactory, standalone, ai) {
         const resources = this.#subscriptionRegistry === undefined ? {} : { registry: this.#subscriptionRegistry };
         this.#subscriptionRegistry = undefined;
         const registeredRepositories = [...repositories];
@@ -1040,7 +1485,7 @@ export class BoundedContextBuilder {
             return this.#assembleContext(registeredRepositories, storageFactory, standalone, resources, ai);
         }
         catch (error) {
-            return this.#failBuild(resources, error);
+            return await this.#failBuild(resources, error);
         }
     }
     #assembleContext(repositories, storageFactory, standalone, resources, ai) {
@@ -1059,6 +1504,10 @@ export class BoundedContextBuilder {
         ]);
         const running = this.#buildRuntime(storageFactory, buses, resources);
         const context = this.#createContext(repositories, storageFactory, buses, running, ai);
+        resources.context = context;
+        if (registerBoundedContext === undefined)
+            throw new Error("Context registration is unavailable.");
+        registerBoundedContext(context, repositories);
         ContextParts.attachIntegration(context, buses.eventBus, buses.systemSpec, ContextParts.externalEventSchemas([
             ...dispatchers.domain,
             ...(standaloneEvent === undefined ? [] : [standaloneEvent]),
@@ -1083,31 +1532,14 @@ export class BoundedContextBuilder {
             throw new TypeError("Agent registration requires persisted System Events.");
         if (!AgentHistoryStorageFactories.supports(storageFactory))
             throw new TypeError("Agent registration requires indexed history storage.");
-        if (!AgentExecutionStorageFactories.supports(storageFactory))
-            throw new TypeError("Agent registration requires durable execution storage.");
-        this.#checkAgentOutputBindings(agents);
         for (const repository of agents) {
             const config = repositoryAccess.agentConfiguration(repository);
-            if (config.codeRevision === undefined || config.codeRevision.trim() === "")
-                throw new TypeError("Agent registration requires a code revision.");
             if (config.ai === undefined)
                 throw new TypeError("Agent registration requires repository capabilities.");
             if (config.ai.models.some((model) => !isAiModel(model)))
                 throw new TypeError("Agent repository capabilities must be factory-created models.");
         }
     }
-    /**
-     * Rejects Agent outcomes whose raw matching dispatcher cannot bind a saved plan.
-     */
-    #checkAgentOutputBindings(agents) {
-        const rawCommands = new Set([...this.#commandDispatchers].flatMap((dispatcher) => dispatcher.messageSchemas().map((schema) => TypeUrls.derive(schema))));
-        for (const repository of agents) {
-            if (repositoryAccess
-                .producedCommandSchemas(repository)
-                .some((schema) => rawCommands.has(TypeUrls.derive(schema))))
-                throw new TypeError("Agent Command output requires a durable dispatcher binding.");
-        }
-    }
     #buildDispatchers(repositories) {
         const event = [
             ...ContextParts.repositoryEventDispatchers(repositories),
@@ -1148,7 +1580,7 @@ export class BoundedContextBuilder {
     #buildSystemBuses(storageFactory, dispatchers, resources) {
         const systemSpec = ContextParts.createSystemSpec(this.#specSnapshot, this.#persistSystemEvents);
         const systemEventStore = systemSpec.storesEvents
-            ? new EventStore(ContextParts.createStorageMode(systemSpec), storageFactory, systemEventGroup)
+            ? new EventStore(ContextParts.createStorageMode(systemSpec), storageFactory, EventStoreGroups.forContext(systemSpec.name.value, "system"))
             : undefined;
         if (systemEventStore !== undefined)
             resources.systemEventStore = systemEventStore;
@@ -1185,10 +1617,7 @@ export class BoundedContextBuilder {
         return event;
     }
     #buildRuntime(storageFactory, buses, resources) {
-        const stand = new Stand({
-            context: ContextParts.createStorageMode(this.#specSnapshot),
-            storageFactory,
-        });
+        const stand = this.#buildStand(storageFactory);
         resources.stand = stand;
         const registry = resources.registry ??
             new StorageSubscriptionRegistry(ContextParts.createSubscriptionStorageContext(this.#specSnapshot), storageFactory);
@@ -1197,19 +1626,50 @@ export class BoundedContextBuilder {
         resources.runtime = runtime;
         return { stand, registry, runtime };
     }
+    /**
+     * Builds the context Stand with a captured live membership directory.
+     *
+     * @param storageFactory Provider used for Entity records.
+     * @returns Direct read-side Stand.
+     */
+    #buildStand(storageFactory) {
+        const tenantIndex = this.#tenantIndex ?? ServerEnvironment.instance().tenantIndex;
+        const stand = new Stand({
+            context: ContextParts.createStorageMode(this.#specSnapshot),
+            storageFactory,
+        });
+        standAccess.setAdmission(stand, (tenantId) => TenantAdmissions.require(tenantIndex, this.#specSnapshot.name.value, this.#specSnapshot.multitenant, tenantId));
+        return stand;
+    }
     #createContext(repositories, storageFactory, buses, running, ai) {
-        return ContextParts.createBoundedContext(this.#specSnapshot, storageFactory, repositories, this.#deliveryStrategy, buses, running, ai);
+        return ContextParts.createBoundedContext(this.#specSnapshot, storageFactory, repositories, ServerEnvironment.instance().delivery.strategy, buses, running, ai, this.#tenantIndex ?? ServerEnvironment.instance().tenantIndex);
     }
-    #failBuild(resources, error) {
+    async #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 (resources.context !== undefined) {
+            try {
+                await resources.context.close();
+            }
+            catch (closeError) {
+                cleanupErrors.push(closeError);
+            }
+        }
+        else {
+            ContextParts.attemptCleanup(() => resources.publisher?.abortAssembly(), cleanupErrors);
+            const registry = resources.runtime ?? resources.registry;
+            const closing = [registry, resources.stand, resources.systemStand];
+            for (const resource of closing) {
+                if (resource === undefined)
+                    continue;
+                try {
+                    await resource.close();
+                }
+                catch (closeError) {
+                    cleanupErrors.push(closeError);
+                }
+            }
+            await ContextParts.cleanupBuildBuses(resources, cleanupErrors);
+        }
         if (cleanupErrors.length > 0) {
             throw new AggregateError([error, ...cleanupErrors], "Bounded Context build failed during cleanup.");
         }
@@ -1409,24 +1869,29 @@ const ContextParts = Object.freeze({
      *
      * @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 Completion after all created buses and stores close.
+     */
+    async cleanupBuildBuses(resources, errors) {
+        const closing = [];
+        const { commandBus, systemEventBus, systemEventStore, eventBus, eventStore } = resources;
+        if (commandBus !== undefined)
+            closing.push(() => commandBus.close());
+        if (systemEventBus !== undefined)
+            closing.push(() => systemEventBus.close());
+        else if (systemEventStore !== undefined)
+            closing.push(() => systemEventStore.close());
+        if (eventBus !== undefined)
+            closing.push(() => eventBus.close());
+        else if (eventStore !== undefined)
+            closing.push(() => eventStore.close());
+        for (const close of closing) {
+            try {
+                await close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
     },
     /**
      * Returns constituent failures from nested aggregate errors.
@@ -1476,9 +1941,10 @@ const ContextParts = Object.freeze({
      * @param buses Prepared domain and System buses.
      * @param running Prepared Stand and subscription runtime.
      * @param ai Effective AI registry when Agent repositories are present.
+     * @param tenantIndex Effective live membership index.
      * @returns Constructed bounded context.
      */
-    createBoundedContext(specSnapshot, storageFactory, repositories, deliveryStrategy, buses, running, ai) {
+    createBoundedContext(specSnapshot, storageFactory, repositories, deliveryStrategy, buses, running, ai, tenantIndex) {
         return constructBoundedContext({
             snapshot: ContextParts.snapshotFor(specSnapshot),
             commandBus: buses.commandBus,
@@ -1490,6 +1956,7 @@ const ContextParts = Object.freeze({
             subscriptionRuntime: running.runtime,
             systemSpec: buses.systemSpec,
             storageFactory,
+            tenantIndex: tenantIndex ?? ServerEnvironment.instance().tenantIndex,
             repositories,
             deliveryStrategy,
             ...(ai === undefined ? {} : { ai }),
@@ -1533,35 +2000,6 @@ const ContextParts = Object.freeze({
             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.");
-        }
-        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) {
-                    throw new Error("Delivery strategy shard total must equal its resolved shard count.");
-                }
-                return new ShardIndex(shard.index, shard.ofTotal);
-            },
-        });
-    },
     /**
      * Creates the storage context for read-side catch-up.
      *
@@ -1740,8 +2178,7 @@ const ContextParts = Object.freeze({
             },
         });
         const ready = broker.open();
-        // Synchronous build returns before readiness; retain the failure for the next
-        // observable operation without letting Node report an unhandled rejection.
+        // The builder awaits readiness; retain a rejection handler until it observes the result.
         void ready.catch(() => undefined);
         contextIntegrations.set(context, { broker, ready });
     },
@@ -1878,21 +2315,9 @@ const ContextParts = Object.freeze({
      */
     requireEntityClass(entityType, operation) {
         if (typeof entityType !== "function") {
-            throw new TypeError(`${operation} requires a Repository instance. Use an entity class only with buildAsync().`);
+            throw new TypeError(`${operation} requires a Repository instance. Use an entity class only with build().`);
         }
     },
-    /**
-     * Rejects synchronous assembly when classes need generated metadata.
-     *
-     * @param entityTypes Entity classes to assemble.
-     */
-    rejectSyncEntityAssembly(entityTypes) {
-        if (entityTypes.size === 0) {
-            return;
-        }
-        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.
      *
@@ -1903,7 +2328,7 @@ const ContextParts = Object.freeze({
         if (root !== undefined) {
             return root;
         }
-        throw new Error("BoundedContextBuilder.buildAsync() requires withGeneratedRegistryRoot(root) " +
+        throw new Error("BoundedContextBuilder.build() requires withGeneratedRegistryRoot(root) " +
             "when assembling entity classes from generated metadata.");
     },
     /**
@@ -2295,16 +2720,6 @@ 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.
      *
@@ -2327,68 +2742,25 @@ const ContextParts = Object.freeze({
         contextStorageFactories.delete(context);
         contextDeliveryDescriptors.delete(context);
         contextSubscriptionRuntimes.delete(context);
+        contextInputPreparations.delete(context);
+        contextPreparations.delete(context);
         contextIntegrations.delete(context);
         eventSubscribers.delete(context);
         systemEventPosters.delete(context);
     },
     /**
-     * Creates delivery operations from the context inboxes and readiness state.
+     * Creates delivery operations from the context inboxes.
      *
-     * @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) {
+    createDeliveryDescriptor(entityInbox, projections) {
         return Object.freeze({
-            storageFactory,
-            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,
         });
     },
     /**
@@ -2488,7 +2860,7 @@ const ContextParts = Object.freeze({
                 registeredRepositories.set(repository, { name: registration.name });
             },
             close: () => {
-                repositoryAccess.clearRuntime(repository);
+                repositoryAccess.clearRuntimeIdle(repository);
             },
         };
     },
@@ -2502,6 +2874,7 @@ const ContextParts = Object.freeze({
         repositoryAccess.bindRuntime(repository, {
             context: registration.storageContext,
             storageFactory: registration.storageFactory,
+            onAdmit: registration.onAdmit,
             ...(registration.ai === undefined ? {} : { ai: registration.ai }),
             stand: registration.stand,
             signalMetadata: new SignalMetadata(),
@@ -2511,11 +2884,11 @@ const ContextParts = Object.freeze({
             registerEventSchema: registration.registerEventSchema,
             registerSystemEventSchema: registration.registerSystemEventSchema,
             publishAgentEvent: registration.publishAgentEvent,
-            prepareSavedCommand: registration.prepareSavedCommand,
-            publishSavedCommand: registration.publishSavedCommand,
             publishAgentSystemEvent: registration.publishAgentSystemEvent,
-            recordAcceptedSaved: registration.recordAcceptedSaved,
-            wakeAcceptedAgent: registration.wakeAcceptedAgent,
+            agentReceipts: registration.agentReceipts,
+            agentSignal: registration.agentSignal,
+            reserveAgent: registration.reserveAgent,
+            deferAgent: registration.deferAgent,
         });
     },
     /**
@@ -2637,7 +3010,7 @@ const ContextParts = Object.freeze({
             });
         }
         finally {
-            eventStore.close();
+            await eventStore.close();
         }
     },
     /**