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

package/dist/context/bounded-context.js

@@ -11,45 +11,34 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-import { constants as fsConstants } from "node:fs";
-import { access, realpath } from "node:fs/promises";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { clone, create, getOption, hasOption } from "@bufbuild/protobuf";
 import { freezeRegistry, isAiModel, registryOptions } from "@spine-event-engine/ai/spi/runtime";
 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 { SpineMetadataInventory } from "../handler/spine-metadata-inventory.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 { ReadSideFilter } from "../stand/read-side-filter.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, subscriptionRecordGroup, } 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,20 +62,51 @@ 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,
 });
-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();
 const eventSubscribers = new WeakMap();
 const contextSystemPairings = new WeakMap();
 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 +117,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 +135,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 +182,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 +196,305 @@ 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) {
+        const registry = this.#subscriptionRuntime.registry();
+        if (!(registry instanceof StorageSubscriptionRegistry))
+            return Promise.resolve();
+        if (this.#sharedPreparation !== undefined)
+            return this.#sharedPreparation;
+        const attempt = this.#trackPreparation(() => registry.prepare(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,42 +510,29 @@ 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));
+        contextDeliveryDescriptors.set(this, ContextParts.createDeliveryDescriptor(this.#entityInbox, this.#projectionInbox));
     }
     /**
-     * Registers repositories and starts subscriptions, closing the tenant index on failure.
-     *
-     * @param repositories Prepared repositories.
-     * @param tenantIndex Index to close if registration fails.
+     * Prepares repository registrations, reserves their state types, and commits their Stand and
+     * inbox targets; rolls back uncommitted storage preparation on failure.
      */
-    #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;
-        }
-    }
     #registerRepositories(repositories) {
         const preparedRepositories = this.#prepareRepositories(repositories);
         try {
             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 +552,23 @@ 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);
+        }
+    }
+    /**
+     * Builds prepared repository registrations using this context’s storage and delivery services,
+     * cleaning earlier preparations if a later one fails.
+     */
     #prepareRepositories(repositories) {
         const registration = this.#repositoryRegistration();
         const preparedRepositories = [];
@@ -312,14 +582,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 +615,42 @@ 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 }),
+        });
+    }
+    /**
+     * Closes storage for repositories that were prepared but not committed, then rethrows the
+     * registration error with cleanup failures aggregated.
+     */
     #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 +698,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.
      *
@@ -497,6 +808,10 @@ export class BoundedContext {
     async catchUpReadSide(options = {}) {
         return eventBusAccess.runExclusive(this.#eventBus, () => this.#catchUpReadSideOnce(options));
     }
+    /**
+     * Clears registered Projection state for the selected tenant slice, reads stored events,
+     * validates each event’s tenant, and dispatches replay sequentially.
+     */
     async #catchUpReadSideOnce(options) {
         const storageContext = ContextParts.catchUpStorageContext(this.#snapshot.spec, options);
         const tenantOptions = ContextParts.catchUpStandOptions(storageContext);
@@ -539,7 +854,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 +882,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 +932,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 +966,73 @@ 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);
+    },
+    /**
+     * Registers replay work with the context close lifecycle so shutdown waits for it.
+     */
+    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.
      *
@@ -638,18 +1049,27 @@ export const boundedContextAccess = Object.freeze({
             ? issued.repository
             : undefined;
     },
+    /**
+     * Stops new work at this Bounded Context and begins shutdown of its runtime facilities.
+     */
     beginClose(context) {
         const phase = contextClosePhases.get(context);
         if (phase === undefined)
             throw new TypeError("Close phase requires a built BoundedContext.");
         phase.begin();
     },
+    /**
+     * Waits for accepted runtime work and replay operations to finish.
+     */
     drainWork(context) {
         const phase = contextClosePhases.get(context);
         if (phase === undefined)
             return Promise.reject(new TypeError("Drain requires a built BoundedContext."));
         return phase.drain();
     },
+    /**
+     * Installs the context logger on both EventBuses, the signal publisher, and subscription runtime.
+     */
     installLogger(context, logger) {
         if (!contextStorageFactories.has(context)) {
             throw new TypeError("Context logger requires a built BoundedContext instance.");
@@ -669,8 +1089,11 @@ 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);
     },
+    /**
+     * Returns the diagnostic logger installed on this Bounded Context.
+     */
     loggerFor(context) {
         const logger = contextLoggers.get(context);
         if (logger === undefined) {
@@ -678,18 +1101,27 @@ export const boundedContextAccess = Object.freeze({
         }
         return logger;
     },
+    /**
+     * Checks whether a value is a BoundedContextBuilder created by this module.
+     */
     isBuilder(value) {
         return (typeof value === "object" &&
             value !== null &&
             builderBuilds.has(value));
     },
-    build(builder, defaultStorageFactory, defaultAi) {
+    /**
+     * Builds the supplied context builder and completes its configured initialization.
+     */
+    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();
     },
+    /**
+     * Attaches a subscriber to the context domain EventBus for the requested event type.
+     */
     subscribeToEvent(context, typeUrl, subscriber) {
         const subscribe = eventSubscribers.get(context);
         if (subscribe === undefined) {
@@ -697,6 +1129,9 @@ export const boundedContextAccess = Object.freeze({
         }
         return subscribe(typeUrl, subscriber);
     },
+    /**
+     * Posts a framework System Event through the context System EventBus.
+     */
     postSystemEvent(context, event) {
         const post = systemEventPosters.get(context);
         if (post === undefined) {
@@ -704,12 +1139,18 @@ export const boundedContextAccess = Object.freeze({
         }
         return post(event);
     },
+    /**
+     * Posts an external domain Event through the context EventBus.
+     */
     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);
     },
+    /**
+     * Subscribes to events produced by this context and forwards matching signals to the supplied observer.
+     */
     observeProducedSignals(context, observer) {
         const publisher = contextSignalPublishers.get(context);
         if (publisher === undefined) {
@@ -717,12 +1158,21 @@ export const boundedContextAccess = Object.freeze({
         }
         return publisher.observe(observer);
     },
+    /**
+     * Returns the domain/System specification pairing captured when the context was built.
+     */
     systemPairing(context) {
         return ContextParts.cloneSystemPairing(ContextParts.requireSystemPairing(context));
     },
+    /**
+     * Returns the live tenant membership index configured for this context.
+     */
     tenantIndex(context) {
         return ContextParts.requireTenantIndex(context);
     },
+    /**
+     * Returns the storage factory captured for repository and Stand operations in this context.
+     */
     storageFactory(context) {
         const storageFactory = contextStorageFactories.get(context);
         if (storageFactory === undefined) {
@@ -730,6 +1180,9 @@ export const boundedContextAccess = Object.freeze({
         }
         return storageFactory;
     },
+    /**
+     * Returns the persistent or in-memory registry used to store Stand subscription definitions.
+     */
     subscriptionRegistry(context) {
         const runtime = contextSubscriptionRuntimes.get(context);
         if (runtime === undefined) {
@@ -737,13 +1190,24 @@ export const boundedContextAccess = Object.freeze({
         }
         return runtime.registry();
     },
-    consumeSubscription(context, id, onUpdate) {
+    /**
+     * Consumes a registered Stand subscription update and returns its managed delivery handle.
+     */
+    consumeSubscription(context, id, onUpdate, onInvalidated, expected) {
         const runtime = contextSubscriptionRuntimes.get(context);
         if (runtime === undefined) {
             throw new TypeError("Subscription consumption requires a built BoundedContext instance.");
         }
-        return runtime.consume(id, onUpdate);
+        return runtime.consume(id, (update) => {
+            onUpdate({
+                update,
+                filter: (facts) => standAccess.filterSubscription(context.stand(), update, facts),
+            });
+        }, onInvalidated, expected);
     },
+    /**
+     * Returns the context delivery descriptor used to route Entity and Projection inbox work.
+     */
     delivery(context) {
         const descriptor = contextDeliveryDescriptors.get(context);
         if (descriptor === undefined) {
@@ -764,13 +1228,12 @@ export class BoundedContextBuilder {
     #eventReceivers = [];
     #repositories = new Set();
     #entityTypes = new Set();
+    #readFilters = new Set();
     #generatedRepositoryOptions = new Map();
-    #deliveryStrategy = UniformAcrossAllShards.singleShard();
-    #storageFactory;
     #aiRegistry;
+    #tenantIndex;
     #subscriptionRegistry;
     #persistSystemEvents = false;
-    #generatedRegistryRoot;
     /**
      * Registers the framework-only construction hook for this module.
      */
@@ -786,7 +1249,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);
     }
     /**
@@ -821,6 +1284,15 @@ export class BoundedContextBuilder {
     isMultitenant() {
         return this.#specSnapshot.multitenant;
     }
+    /**
+     * Adds an outward read policy to this Bounded Context.
+     * @param filter Policy applied before Server-level outward policies.
+     * @returns This builder for further configuration.
+     */
+    addReadSideFilter(filter) {
+        this.#readFilters.add(filter);
+        return this;
+    }
     /**
      * Adds an explicitly assembled repository or an Entity class.
      *
@@ -861,7 +1333,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 +1360,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 +1377,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 +1397,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;
     }
     /**
@@ -970,69 +1442,112 @@ export class BoundedContextBuilder {
         return this;
     }
     /**
-     * Sets how Entity Inbox targets are assigned to shards.
+     * Builds a context after loading generated handlers and preparing runtime resources.
      *
-     * @param strategy Selects the durable shard for Aggregate and Process Manager targets.
-     * @returns Returns this builder for further configuration.
+     * @param options Independent eager structure and subscription timing choices.
+     * @returns The built context after requested initialization and integration are ready.
      */
-    withDeliveryStrategy(strategy) {
-        this.#deliveryStrategy = ContextParts.snapshotDeliveryStrategy(strategy);
-        return this;
+    build(options = {}) {
+        return this.#buildAsyncWith(options);
     }
     /**
-     * Sets a trusted compiled application root for generated handler metadata.
-     *
-     * @param root Names the compiled package or application root.
-     * @returns Returns this builder for further configuration.
+     * Loads generated handlers and repositories, assembles context facilities, and completes
+     * requested initialization before publishing the context.
      */
-    withGeneratedRegistryRoot(root) {
-        this.#generatedRegistryRoot = root;
-        return this;
+    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();
+        }
+        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 from explicitly added repositories and dispatchers.
+     * Loads generated metadata and finishes one asynchronous context assembly.
      *
-     * @returns Returns the built context.
+     * @returns The integrated context.
      */
-    build() {
-        if (this.#standaloneInstances().length > 0) {
-            throw new Error("Standalone generated handlers require buildAsync().");
+    async #buildAsyncReady(options, environment) {
+        const generated = this.#loadGeneratedArtifacts([...this.#entityTypes]);
+        serverEnvironmentAccess.requireAvailable(environment);
+        const repositories = [...this.#repositories, ...generated.repositories];
+        const context = await this.#buildWithResources(repositories, environment.storageFactory, generated.standalone, this.#aiRegistry ?? environment.ai);
+        try {
+            await this.#integrateBuiltContext(context, options, environment);
+        }
+        catch (error) {
+            return this.#closeFailedBuild(context, environment, error);
         }
-        ContextParts.rejectSyncEntityAssembly(this.#entityTypes);
-        return this.#buildWith([...this.#repositories], this.#storageFactory ?? new InMemoryStorageFactory(), [], this.#aiRegistry);
+        return context;
     }
     /**
-     * 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.
+     * Completes required integration and requested initialization before publication.
+     * @param context Constructed context.
+     * @param options Requested eager initialization phases.
+     * @param environment Captured environment lifetime.
      */
-    async buildAsync() {
-        return this.#buildAsyncWith();
-    }
-    async #buildAsyncWith(defaultStorageFactory, defaultAi) {
-        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, this.#aiRegistry ?? defaultAi);
+    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 ContextParts.integrationReady(context);
+            await context.close();
         }
-        catch (error) {
-            try {
-                await context.close();
-            }
-            catch (closeError) {
-                throw new AggregateError([error, closeError], "BoundedContext broker open failed during cleanup.");
+        catch (closeError) {
+            if (serverEnvironmentAccess.hasStartupFailure(environment)) {
+                serverEnvironmentAccess.recordStartupCleanup(environment, closeError);
+                throw error;
             }
-            throw error;
+            throw new AggregateError([error, closeError], "BoundedContext open cleanup failed.");
         }
-        return context;
+        throw error;
     }
-    #buildWith(repositories, storageFactory, standalone = [], ai) {
+    /**
+     * 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,9 +1555,13 @@ export class BoundedContextBuilder {
             return this.#assembleContext(registeredRepositories, storageFactory, standalone, resources, ai);
         }
         catch (error) {
-            return this.#failBuild(resources, error);
+            return await this.#failBuild(resources, error);
         }
     }
+    /**
+     * Assembles dispatchers, buses, Stand, subscription runtime, and integration hooks, registering
+     * the completed context with its environment.
+     */
     #assembleContext(repositories, storageFactory, standalone, resources, ai) {
         ContextParts.preflightRepositories(repositories);
         this.#preflightAgents(repositories, storageFactory, ai);
@@ -1059,6 +1578,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,13 +1606,8 @@ 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)))
@@ -1097,17 +1615,8 @@ export class BoundedContextBuilder {
         }
     }
     /**
-     * Rejects Agent outcomes whose raw matching dispatcher cannot bind a saved plan.
+     * Collects repository and configured event recipients into domain and System dispatcher groups.
      */
-    #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),
@@ -1121,6 +1630,9 @@ export class BoundedContextBuilder {
             ],
         };
     }
+    /**
+     * Creates command, domain Event, and System Event buses plus their stores and signal publisher.
+     */
     #buildBuses(repositories, storageFactory, dispatchers, resources) {
         const commandBus = new CommandBus([
             ...this.#commandDispatchers,
@@ -1145,10 +1657,13 @@ export class BoundedContextBuilder {
             systemSpec: system.spec,
         };
     }
+    /**
+     * Creates the System context store, EventBus, and Stand, then registers System event dispatchers.
+     */
     #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;
@@ -1168,6 +1683,10 @@ export class BoundedContextBuilder {
             spec: systemSpec,
         };
     }
+    /**
+     * Matches generated standalone handlers to configured instances and registers their dispatchers
+     * on the appropriate buses.
+     */
     #installStandalone(standalone, buses) {
         ContextParts.assertUniqueCommandReceptors(standalone);
         const runtime = standalone.length === 0
@@ -1184,59 +1703,98 @@ export class BoundedContextBuilder {
             buses.systemEventBus.register(state);
         return event;
     }
+    /**
+     * Creates the context Stand, subscription registry, and runtime that observes domain and System events.
+     */
     #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);
+            new StorageSubscriptionRegistry(ContextParts.createSubscriptionStorageContext(this.#specSnapshot), storageFactory, subscriptionRecordGroup(this.#specSnapshot.name.value));
         resources.registry = registry;
         const runtime = new SubscriptionRuntime(stand, buses.systemStand, buses.eventBus, buses.systemEventBus, registry);
         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,
+        });
+        if (this.#readFilters.size > 0)
+            standAccess.installReadFilters(stand, [...this.#readFilters]);
+        standAccess.setAdmission(stand, (tenantId) => TenantAdmissions.require(tenantIndex, this.#specSnapshot.name.value, this.#specSnapshot.multitenant, tenantId));
+        return stand;
+    }
+    /**
+     * Constructs the immutable BoundedContext using assembled buses, runtime parts, environment
+     * delivery strategy, and tenant index.
+     */
     #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) {
+    /**
+     * Closes partial context resources after assembly fails and aggregates cleanup errors with the original failure.
+     */
+    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.");
         }
         throw error;
     }
-    async #loadGeneratedArtifacts(entityTypes) {
+    /**
+     * Selects generated metadata for configured Entity and standalone handler types and creates
+     * repository views and handler groups.
+     */
+    #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();
-        const registryModule = await ContextParts.trustedGeneratedRegistryModule(root);
-        const registryKey = registryModule.href;
-        const registries = (await discovery
-            .load({
-            modules: [registryModule],
-            ...ContextParts.generatedRegistryCacheBust(registryKey),
-        })
-            .catch((error) => {
-            ContextParts.recordGeneratedRegistryFailure(registryKey);
-            throw error;
-        }));
+        const selected = [
+            ...entityTypes,
+            ...this.#standaloneInstances().map((instance) => instance.constructor),
+        ];
+        const registries = [SpineMetadataInventory.select(selected)];
         const metadata = ContextParts.ingestGeneratedRegistries(registries);
         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 });
     }
+    /**
+     * Returns a frozen list of configured standalone assignee, commander, and event-receiver instances.
+     */
     #standaloneInstances() {
         return Object.freeze([...this.#assignees, ...this.#commanders, ...this.#eventReceivers]);
     }
@@ -1409,24 +1967,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,10 +2039,11 @@ 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) {
-        return constructBoundedContext({
+    createBoundedContext(specSnapshot, storageFactory, repositories, deliveryStrategy, buses, running, ai, tenantIndex) {
+        const context = constructBoundedContext({
             snapshot: ContextParts.snapshotFor(specSnapshot),
             commandBus: buses.commandBus,
             eventBus: buses.eventBus,
@@ -1490,11 +2054,14 @@ const ContextParts = Object.freeze({
             subscriptionRuntime: running.runtime,
             systemSpec: buses.systemSpec,
             storageFactory,
+            tenantIndex: tenantIndex ?? ServerEnvironment.instance().tenantIndex,
             repositories,
             deliveryStrategy,
             ...(ai === undefined ? {} : { ai }),
             token: frameworkConstructionToken,
         });
+        standAccess.bindProducingContext(running.stand, context);
+        return context;
     },
     /**
      * Captures public context identity from the build specification.
@@ -1533,35 +2100,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 +2278,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,166 +2415,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().`);
-        }
-    },
-    /**
-     * 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.
-     *
-     * @param root Configured registry location.
-     * @returns Configured root; throws when absent.
-     */
-    requireGeneratedRegistryRoot(root) {
-        if (root !== undefined) {
-            return root;
-        }
-        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);
-        const canonicalRegistryPath = await ContextParts.canonicalReadableRegistryPath(registryPath);
-        if (ContextParts.resolvesOutsideRoot(trustedRoot, canonicalRegistryPath)) {
-            throw new Error(`Generated handler registry module "${canonicalRegistryPath}" must resolve within ` +
-                `the configured generated registry root "${trustedRoot}".`);
-        }
-        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 {
-            return await realpath(rootPath);
-        }
-        catch (error) {
-            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");
-        }
-        if (ContextParts.isUrlLike(root)) {
-            return ContextParts.fileUrlPath(ContextParts.parseRootUrl(root), "Generated registry root");
-        }
-        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.`);
-        }
-        if (url.search.length > 0 || url.hash.length > 0) {
-            throw new Error(`${label} "${url.href}" must not include a query or hash.`);
-        }
-        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);
-        }
-        catch (error) {
-            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);
-            return await realpath(registryPath);
-        }
-        catch (error) {
-            throw new Error(`Generated handler registry module "${registryPath}" must exist and be readable.`, { cause: error });
+            throw new TypeError(`${operation} requires a Repository instance. Use an entity class only with build().`);
         }
     },
-    /**
-     * 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("..") ||
-            relativePath === ".." ||
-            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.
      *
@@ -2295,16 +2675,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 +2697,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 +2815,7 @@ const ContextParts = Object.freeze({
                 registeredRepositories.set(repository, { name: registration.name });
             },
             close: () => {
-                repositoryAccess.clearRuntime(repository);
+                repositoryAccess.clearRuntimeIdle(repository);
             },
         };
     },
@@ -2502,6 +2829,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 +2839,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 +2965,7 @@ const ContextParts = Object.freeze({
             });
         }
         finally {
-            eventStore.close();
+            await eventStore.close();
         }
     },
     /**
@@ -2787,9 +3115,15 @@ const ContextParts = Object.freeze({
  * @internal
  */
 export const boundedContextIntegrationAccess = Object.freeze({
+    /**
+     * Publishes an imported Event through the context’s import path.
+     */
     publishImported(context, event) {
         return ContextParts.publishImported(context, event);
     },
+    /**
+     * Signals that standalone context integration is ready.
+     */
     ready(context) {
         return ContextParts.integrationReady(context);
     },