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

package/dist/server/server.js

@@ -12,10 +12,18 @@
  * the License.
  */
 import * as http2 from "node:http2";
+import { clone } from "@bufbuild/protobuf";
+import { ActorContextSchema } from "@spine-event-engine/proto";
+import { snapshotTrustedReader, } from "@spine-event-engine/core/spi/trusted-reader";
 import { connectNodeAdapter } from "@connectrpc/connect-node";
 import { BoundedContext, BoundedContextBuilder, boundedContextAccess, } from "../context/bounded-context.js";
 import { SpineServices, spineServicesAccess, } from "../services/spine-services.js";
 import { RegisteredTargets } from "../services/registered-targets.js";
+import { AppQueryExecution } from "../services/app-query-execution.js";
+import { ReadSideFilter } from "../stand/read-side-filter.js";
+import { ReadSideFilterEngine } from "../stand/read-side-filter-engine.js";
+import { TypeRegistry } from "@spine-event-engine/core";
+import { registeredProtoModules } from "@spine-event-engine/proto/codegen";
 import { ProcessServerCoordinator } from "./process-server-coordinator.js";
 import { CloseErrors, RetryableCloseGroup } from "./retryable-close.js";
 import { ServerEnvironment, serverEnvironmentAccess } from "./server-environment.js";
@@ -30,10 +38,9 @@ const assemblingStands = new WeakMap();
 /**
  * Configures and starts local Spine Connect/gRPC-compatible services.
  *
- * A server assembles its bounded contexts, completes finite environment
- * delivery recovery, and opens its generated services before accepting network
- * requests. It also owns the ordered cleanup of contexts and resources added
- * to this assembly.
+ * A server assembles its bounded contexts and opens generated services before
+ * accepting network requests. It closes its contexts and added resources in
+ * order while environment Delivery remains available to sibling contexts.
  */
 export class Server {
     #host;
@@ -41,14 +48,16 @@ export class Server {
     #readMaxBytes;
     #writeMaxBytes;
     #contexts = [];
-    #aiRegistry;
     #resources = [];
     #listenerLifecycles = [];
+    #appQueries;
+    #readFilters;
     #services;
     #environment;
     #starting;
     #startingOwnership;
     #run;
+    #active;
     #failedStartCleanup;
     #failedListenerLifecycle;
     #failedStartConsumed = false;
@@ -63,6 +72,8 @@ export class Server {
         this.#readMaxBytes = ServerValues.normalizeMessageMaxBytes(options.readMaxBytes ?? defaultMessageMaxBytes, "readMaxBytes");
         this.#writeMaxBytes = ServerValues.normalizeMessageMaxBytes(options.writeMaxBytes ?? defaultMessageMaxBytes, "writeMaxBytes");
         this.#contexts.push(...(options.contexts ?? []));
+        this.#appQueries = Object.freeze([...(options.appQueries ?? [])]);
+        this.#readFilters = Object.freeze([...new Set(options.readSideFilters ?? [])]);
         this.#resources.push(...(options.resources ?? []));
         this.#services = options.services ?? {};
         this.#environment = ServerEnvironment.instance();
@@ -81,10 +92,9 @@ export class Server {
     /**
      * Adds one bounded context or builder to the assembly.
      *
-     * Builders assemble during {@link start} before recovery and listener open.
-     * They use {@link ServerEnvironment.storageFactory} unless a more specific
-     * `withStorageFactory(...)` factory is selected. The running server owns and
-     * closes added contexts only after services, sessions, and active work stop.
+     * Builders assemble during {@link start} before the listener opens.
+     * They use {@link ServerEnvironment.storageFactory}. The running server closes
+     * added contexts after services, sessions, and active work stop.
      *
      * @param context Supplies the context or builder to expose.
      * @returns This server builder.
@@ -94,15 +104,22 @@ export class Server {
         return this;
     }
     /**
-     * Sets the default AI registry for Bounded Context builders added to this server.
-     * An explicit Bounded Context registry takes precedence.
+     * Executes a generated application request through this Server's active handler table.
      *
-     * @param registry Factory-created deployment registry.
-     * @returns This server builder.
+     * @typeParam Q Generated request with a declared paired response.
+     * @param query Generated application request, captured before any await.
+     * @param executionContext Effective actor and verified facts from framework execution.
+     * @returns The paired generated application result.
      */
-    withAi(registry) {
-        this.#aiRegistry = registry;
-        return this;
+    async query(query, executionContext) {
+        const detached = structuredClone(query);
+        const actor = clone(ActorContextSchema, executionContext.actorContext);
+        const reader = snapshotTrustedReader(executionContext);
+        const signal = executionContext.signal;
+        const running = this.#starting === undefined ? this.#active : await this.#starting;
+        if (!(running instanceof RunningHttp2Server))
+            throw new Error("Server App Query execution requires a running Server.");
+        return running.queryTyped(detached, actor, reader, signal);
     }
     /**
      * Adds a framework closeable owned by this server assembly.
@@ -128,15 +145,13 @@ export class Server {
         return this;
     }
     /**
-     * Starts the server after completing assembly and delivery recovery.
+     * Starts the server after assembling contexts and services.
      *
-     * Built contexts attach to delivery in deterministic input order before the
-     * generated services and listener open. A failed assembly or listener open
-     * leaves no listener and closes acquired resources. Network cleanup is a hard
-     * gate before delivery or dependencies close.
-     * It shares only a caller-managed active environment generation, rejects
-     * while run-managed ownership is active, installs no signal handlers, and
-     * never closes the environment.
+     * Built contexts register recipients before generated services and the listener
+     * open. A failed assembly or listener open leaves no listener and closes acquired
+     * resources. Network cleanup is a hard gate before context or dependency cleanup.
+     * Caller-managed startup shares the active environment, rejects during a managed
+     * server run, installs no signal handlers, and never closes the environment.
      * A later call after incomplete cleanup retries only that cleanup and leaves
      * this server terminal. A fresh server may reuse the singleton environment.
      * Concurrent callers share one start or cleanup attempt.
@@ -146,6 +161,9 @@ export class Server {
     start() {
         return this.#start("caller");
     }
+    /**
+     * Shares or begins startup under the selected environment lifecycle mode.
+     */
     #start(ownership) {
         const current = this.#starting;
         if (current !== undefined) {
@@ -162,7 +180,7 @@ export class Server {
         const starting = lifecycle !== undefined
             ? this.#retryFailedListenerLifecycle(lifecycle)
             : cleanup === undefined
-                ? this.#startOnce(ownership)
+                ? this.#startOnce()
                 : this.#retryFailedStartCleanup(cleanup);
         this.#starting = starting;
         this.#startingOwnership = ownership;
@@ -206,37 +224,35 @@ export class Server {
         return running;
     }
     /**
-     * Builds contexts, attaches delivery, and opens the listener for one start attempt.
+     * Builds contexts and opens the listener for one start attempt.
      *
-     * @param ownership Whether the environment is managed by this Server.
      * @returns The running listener after lifecycle startup.
      */
-    async #startOnce(ownership) {
+    async #startOnce() {
+        await serverEnvironmentAccess.awaitSetup(this.#environment);
         const admission = { token: {}, contexts: [] };
         const contexts = await this.#prepareContexts(admission);
-        const { attachment, routes } = await this.#attachContexts(contexts, ownership, admission);
-        const running = await this.#openListener(contexts, attachment, routes);
+        const routes = await this.#installContexts(contexts, admission);
+        const running = await this.#openListener(contexts, routes);
         await this.#startLifecycles(running);
+        this.#active = running;
         return running;
     }
     /**
      * Opens the service listener with retryable cleanup for every preparation phase.
      *
      * @param contexts Contexts exposed by the listener.
-     * @param attachment Active environment delivery attachment.
      * @param routes Routes installed for these contexts.
      * @returns The prepared running listener.
      */
-    async #openListener(contexts, attachment, routes) {
+    async #openListener(contexts, routes) {
         const closeables = [...contexts, ...this.#resources];
         const cleanup = {
             closeGroup: new RetryableCloseGroup(closeables, "Server start cleanup failed while closing owned contexts/resources."),
-            attachment,
             routes,
-            failedStartRollback: undefined,
         };
         try {
-            return await this.#prepareListener(contexts, attachment, routes, closeables, cleanup);
+            return await this.#prepareListener(contexts, routes, closeables, cleanup);
         }
         catch (error) {
             this.#failedStartCleanup = cleanup;
@@ -247,16 +263,13 @@ export class Server {
      * Constructs services and the HTTP adapter, then binds the listener.
      *
      * @param contexts Contexts exposed by this Server.
-     * @param attachment Active delivery attachment.
      * @param routes Installed state routes.
      * @param closeables Contexts and resources for eventual shutdown.
      * @param cleanup Retained cleanup state if preparation fails.
      * @returns The prepared running listener.
      */
-    async #prepareListener(contexts, attachment, routes, closeables, cleanup) {
-        const services = new SpineServices({ contexts, ...this.#services });
-        cleanup.services = services;
-        spineServicesAccess.installLogger(services, serverEnvironmentAccess.loggerFor(this.#environment));
+    async #prepareListener(contexts, routes, closeables, cleanup) {
+        const { queries, services } = this.#createReadServices(contexts, routes, cleanup);
         const { httpServer, sessions } = this.#createHttpListener(services);
         cleanup.network = { server: httpServer, sessions };
         const address = await ServerValues.listen(httpServer, this.#host, this.#port);
@@ -265,8 +278,8 @@ export class Server {
             server: httpServer,
             sessions,
             environment: this.#environment,
-            attachment,
             routes,
+            queries,
             services,
             host,
             port: address.port,
@@ -274,6 +287,31 @@ export class Server {
             closeables,
         });
     }
+    /**
+     * Installs Server result policies and query execution into one listener's services.
+     *
+     * @param contexts Exposed Bounded Contexts.
+     * @param routes Validated Entity state routes.
+     * @param cleanup Retained failure cleanup state.
+     * @returns Listener services and App Query execution lifetime.
+     */
+    #createReadServices(contexts, routes, cleanup) {
+        const filters = this.#readFilters.length === 0
+            ? undefined
+            : new ReadSideFilterEngine(this.#readFilters, TypeRegistry.from(...registeredProtoModules()));
+        const queries = new AppQueryExecution(this.#appQueries, routes, filters);
+        const services = new SpineServices({
+            contexts,
+            readMaxBytes: this.#readMaxBytes,
+            ...this.#services,
+        });
+        cleanup.services = services;
+        spineServicesAccess.installAppQueries(services, queries);
+        if (filters !== undefined)
+            spineServicesAccess.installReadFilters(services, filters);
+        spineServicesAccess.installLogger(services, serverEnvironmentAccess.loggerFor(this.#environment));
+        return { queries, services };
+    }
     /**
      * Prepares an HTTP listener and its tracked sessions for startup.
      *
@@ -326,7 +364,7 @@ export class Server {
                 throw conflict;
             for (const entry of this.#contexts) {
                 const context = boundedContextAccess.isBuilder(entry)
-                    ? await boundedContextAccess.build(entry, this.#environment.storageFactory, this.#aiRegistry)
+                    ? await boundedContextAccess.build(entry)
                     : entry;
                 if (boundedContextAccess.isBuilder(entry))
                     this.#admitContext(context, admission);
@@ -335,7 +373,7 @@ export class Server {
             return contexts;
         }
         catch (error) {
-            await this.#cleanupFailedAttachment(admission.contexts, undefined, error, admission);
+            await this.#cleanupFailedRegistration(admission.contexts, undefined, error, admission);
             throw error;
         }
     }
@@ -368,14 +406,13 @@ export class Server {
         admission.contexts.length = 0;
     }
     /**
-     * Validates state routes before delivery recovery can invoke handlers.
+     * Installs state routes for the assembled contexts.
      *
      * @param contexts Built contexts for this Server.
-     * @param ownership Environment attachment mode.
-     * @param admission Reservations transferred to installed routes before attachment.
-     * @returns The environment attachment and its installed routes.
+     * @param admission Reservations transferred to installed routes.
+     * @returns The installed routes.
      */
-    async #attachContexts(contexts, ownership, admission) {
+    async #installContexts(contexts, admission) {
         const freshContexts = contexts.filter((context) => RegisteredTargets.forStand(context.stand()) === undefined);
         let routes;
         try {
@@ -387,42 +424,29 @@ export class Server {
                 boundedContextAccess.installLogger(context, logger);
                 serverEnvironmentAccess.warnVolatileRegistry(this.#environment, context);
             }
-            const attachment = await serverEnvironmentAccess.attach(this.#environment, {
-                ownership,
-                descriptors: contexts.map((context) => boundedContextAccess.delivery(context)),
-            });
-            return { attachment, routes };
+            return routes;
         }
         catch (error) {
-            await this.#cleanupFailedAttachment(freshContexts, routes, error, admission);
+            await this.#cleanupFailedRegistration(freshContexts, routes, error, admission);
             throw error;
         }
     }
     /**
-     * Retains retryable cleanup when route validation or attachment fails.
+     * Retains retryable cleanup when route installation fails.
      *
      * @param contexts Fresh contexts to close after failure.
      * @param routes Routes installed by this attempt, if any.
-     * @param error Original route or attachment failure.
+     * @param error Original route failure.
      * @param admission Reservations retained until context cleanup succeeds.
      */
-    async #cleanupFailedAttachment(contexts, routes, error, admission) {
+    async #cleanupFailedRegistration(contexts, routes, error, admission) {
         const closeGroup = new RetryableCloseGroup([...contexts, ...this.#resources], "Server start cleanup failed while closing owned contexts/resources.");
-        if (serverEnvironmentAccess.failedStartRetryPending(this.#environment, error)) {
-            this.#failedStartCleanup = {
-                closeGroup,
-                failedStartRollback: { rejection: error },
-                routes,
-                admission,
-            };
-            return;
-        }
         try {
             await closeGroup.close();
         }
         catch (cleanupError) {
-            this.#failedStartCleanup = { closeGroup, failedStartRollback: undefined, routes, admission };
-            throw ServerValues.attachmentCleanupError(error, cleanupError);
+            this.#failedStartCleanup = { closeGroup, routes, admission };
+            throw ServerValues.registrationCleanupError(error, cleanupError);
         }
         routes?.release();
         if (admission !== undefined)
@@ -446,6 +470,9 @@ export class Server {
             throw error;
         }
     }
+    /**
+     * Retries deferred network and resource cleanup from a failed startup, then reports the prior failure.
+     */
     async #retryFailedStartCleanup(cleanup) {
         const errors = [];
         if (!(await this.#closeFailedStartNetwork(cleanup, errors))) {
@@ -457,12 +484,18 @@ export class Server {
         }
         throw new Error("Server deferred cleanup completed after an earlier failed start.");
     }
+    /**
+     * Retries a failed listener lifecycle close and leaves the server terminal.
+     */
     async #retryFailedListenerLifecycle(running) {
         await running.close();
         this.#failedListenerLifecycle = undefined;
         this.#failedStartConsumed = true;
         throw new Error("Server deferred cleanup completed after an earlier failed start.");
     }
+    /**
+     * Cleans up startup resources after listener lifecycle startup fails.
+     */
     async #cleanupFailedListenerStart(cleanup, startError) {
         const errors = [];
         if (!(await this.#closeFailedStartNetwork(cleanup, errors))) {
@@ -471,11 +504,10 @@ export class Server {
         await this.#advanceFailedStartCleanup(cleanup, errors);
         return ServerValues.throwListenerStartError(startError, errors);
     }
+    /**
+     * Closes acquired dependencies and releases startup registrations after network cleanup succeeds.
+     */
     async #advanceFailedStartCleanup(cleanup, errors) {
-        if (!(await this.#advanceFailedStartAttachment(cleanup, errors))) {
-            return;
-        }
-        await this.#retryFailedStartRollback(cleanup, errors);
         let closeFailed = false;
         try {
             await cleanup.closeGroup.close();
@@ -484,7 +516,7 @@ export class Server {
             closeFailed = true;
             CloseErrors.collect(error, errors);
         }
-        if (!closeFailed && cleanup.attachment === undefined && this.#failedStartCleanup === cleanup) {
+        if (!closeFailed && this.#failedStartCleanup === cleanup) {
             cleanup.routes?.release();
             if (cleanup.admission !== undefined)
                 this.#releaseAdmission(cleanup.admission);
@@ -495,26 +527,8 @@ export class Server {
         }
     }
     /**
-     * Retries environment rollback before closing contexts from a failed start.
-     *
-     * @param cleanup Retained failed-start state.
-     * @param errors Errors collected across cleanup phases.
+     * Attempts listener and session shutdown, retaining cleanup state if it fails.
      */
-    async #retryFailedStartRollback(cleanup, errors) {
-        const failedStartRollback = cleanup.failedStartRollback;
-        if (failedStartRollback !== undefined &&
-            serverEnvironmentAccess.failedStartRetryPending(this.#environment, failedStartRollback.rejection)) {
-            try {
-                await serverEnvironmentAccess.retryFailedStart(this.#environment);
-            }
-            catch (error) {
-                if (serverEnvironmentAccess.failedStartRetryPending(this.#environment, failedStartRollback.rejection)) {
-                    throw error;
-                }
-                CloseErrors.collect(error, errors);
-            }
-        }
-    }
     async #closeFailedStartNetwork(cleanup, errors) {
         const network = cleanup.network;
         if (network === undefined) {
@@ -530,34 +544,9 @@ export class Server {
             return false;
         }
     }
-    async #advanceFailedStartAttachment(cleanup, errors) {
-        const attachment = cleanup.attachment;
-        if (attachment === undefined) {
-            return true;
-        }
-        try {
-            if (serverEnvironmentAccess.detachRetryPending(this.#environment, attachment)) {
-                await serverEnvironmentAccess.retryDetach(this.#environment, attachment);
-            }
-            else {
-                await serverEnvironmentAccess.detach(this.#environment, attachment);
-            }
-            delete cleanup.attachment;
-            return true;
-        }
-        catch (error) {
-            CloseErrors.collect(error, errors);
-        }
-        try {
-            if (serverEnvironmentAccess.endpointSafe(this.#environment, attachment)) {
-                return true;
-            }
-        }
-        catch (error) {
-            CloseErrors.collect(error, errors);
-        }
-        return false;
-    }
+    /**
+     * Clears the in-progress startup marker after the shared attempt settles.
+     */
     #finishStart(starting) {
         if (this.#starting === starting) {
             this.#starting = undefined;
@@ -571,11 +560,17 @@ export class Server {
  * @internal
  */
 export const serverBuilderAccess = Object.freeze({
+    /**
+     * Reports whether the configured server host resolves to a loopback address.
+     */
     isLoopback(server) {
         const host = serverHosts.get(server);
         return host !== undefined && isLoopbackHost(host);
     },
 });
+/**
+ * Recognizes IPv4 and IPv6 loopback host spellings accepted by the server.
+ */
 function isLoopbackHost(host) {
     if (host === "::1" || host === "::ffff:127.0.0.1")
         return true;
@@ -588,11 +583,17 @@ function isLoopbackHost(host) {
  * @internal
  */
 export const runningServerAccess = Object.freeze({
+    /**
+     * Returns subscription registries for contexts in this running server, when available.
+     */
     subscriptionRegistries(server) {
         return runningContexts
             .get(server)
             ?.map((context) => boundedContextAccess.subscriptionRegistry(context));
     },
+    /**
+     * Waits for admitted Delivery work across this server’s contexts to settle.
+     */
     drainDelivery(server) {
         return server instanceof RunningHttp2Server ? server.drainDelivery() : Promise.resolve();
     },
@@ -608,15 +609,14 @@ class RunningHttp2Server {
     #listenerLifecycles;
     #startedLifecycles = [];
     #environment;
-    #attachment;
     #routes;
     #services;
+    #queries;
     host;
     port;
     baseUrl;
     #closed;
     #networkClosed = false;
-    #attachmentDetached = false;
     #closeGroup;
     /**
      * Captures the running listener's network, environment, and cleanup resources.
@@ -630,20 +630,36 @@ class RunningHttp2Server {
         this.#contexts = options.contexts;
         this.#listenerLifecycles = options.listenerLifecycles;
         this.#environment = options.environment;
-        this.#attachment = options.attachment;
         this.#routes = options.routes;
         this.#services = options.services;
+        this.#queries = options.queries;
         this.host = options.host;
         this.port = options.port;
         this.baseUrl = `http://${ServerValues.formatHostForUrl(options.host)}:${options.port.toString()}`;
         this.#closeGroup = new RetryableCloseGroup(this.#closeables, "Server close failed while closing owned contexts/resources.");
     }
+    /**
+     * Dispatches a generated request only while this listener remains active.
+     *
+     * @typeParam Q Generated application request with a paired response.
+     * @param query Captured generated request.
+     * @param actor Current effective actor and tenant.
+     * @param reader Verified current invocation facts.
+     * @param signal Current invocation cancellation, when available.
+     * @returns The paired generated application result.
+     */
+    queryTyped(query, actor, reader, signal) {
+        if (this.#closed !== undefined)
+            return Promise.reject(new Error("Server App Query execution is closed."));
+        return this.#queries.executeTyped(query, actor, reader, signal);
+    }
     /**
      * Closes this listener once, preserving a failed close for retry.
      *
      * @returns Completion after resources close.
      */
     close() {
+        this.#queries.beginClose();
         this.#closed ??= this.#closeOnce().catch((error) => {
             this.#closed = undefined;
             throw error;
@@ -651,9 +667,9 @@ class RunningHttp2Server {
         return this.#closed;
     }
     /**
-     * Starts listener-ready attachments after the native listener accepts connections.
+     * Starts listener lifecycles after the native listener accepts connections.
      *
-     * @returns Completes after all attachments start or their admitted rollback settles.
+     * @returns Completes after all listener lifecycles start or their rollback settles.
      */
     async startLifecycles() {
         try {
@@ -681,20 +697,12 @@ class RunningHttp2Server {
         return this.#closed === undefined;
     }
     /**
-     * Completes the server's Delivery detachment while network sessions remain available.
+     * Waits for the environment's admitted Delivery work.
      *
-     * @returns Completion after the attachment drains.
+     * @returns Completion after active shard runs settle.
      */
-    async drainDelivery() {
-        if (this.#attachmentDetached)
-            return;
-        if (serverEnvironmentAccess.detachRetryPending(this.#environment, this.#attachment)) {
-            await serverEnvironmentAccess.retryDetach(this.#environment, this.#attachment);
-        }
-        else {
-            await serverEnvironmentAccess.detach(this.#environment, this.#attachment);
-        }
-        this.#attachmentDetached = true;
+    drainDelivery() {
+        return serverEnvironmentAccess.whenDeliveryIdle(this.#environment);
     }
     /**
      * Closes network, delivery, accepted context work, and registered resources.
@@ -703,7 +711,6 @@ class RunningHttp2Server {
      */
     async #closeOnce() {
         await this.#closeListenerAndNetwork();
-        const { detachErrors, detachRejected } = await this.#detachDelivery();
         const errors = [];
         try {
             await this.#drainContexts();
@@ -718,14 +725,6 @@ class RunningHttp2Server {
         catch (error) {
             errors.push(error);
         }
-        if (detachRejected) {
-            if (errors.length === 0)
-                ServerValues.throwRunningDetachErrors(detachErrors);
-            const combined = [...detachErrors];
-            for (const error of errors)
-                CloseErrors.collect(error, combined);
-            throw new AggregateError(combined, "Server close failed while draining contexts and resources.");
-        }
         if (errors.length > 1)
             throw new AggregateError(errors, "Server close failed while draining contexts and resources.");
         if (errors.length === 1)
@@ -733,7 +732,7 @@ class RunningHttp2Server {
         spineServicesAccess.clearLogger(this.#services);
     }
     /**
-     * Closes lifecycle attachments and network intake before delivery detachment.
+     * Closes lifecycle callbacks and network intake before context cleanup.
      *
      * @returns Completion after the listener and sessions close.
      */
@@ -750,53 +749,20 @@ class RunningHttp2Server {
             this.#networkClosed = true;
         }
     }
-    /**
-     * Completes Delivery detachment while retaining errors for safe endpoint cleanup.
-     *
-     * @returns Detachment errors and whether detachment itself was rejected.
-     */
-    async #detachDelivery() {
-        const detachErrors = [];
-        let detachRejected = false;
-        if (!this.#attachmentDetached) {
-            try {
-                if (serverEnvironmentAccess.detachRetryPending(this.#environment, this.#attachment)) {
-                    await serverEnvironmentAccess.retryDetach(this.#environment, this.#attachment);
-                }
-                else {
-                    await serverEnvironmentAccess.detach(this.#environment, this.#attachment);
-                }
-                this.#attachmentDetached = true;
-            }
-            catch (error) {
-                detachRejected = true;
-                CloseErrors.collect(error, detachErrors);
-            }
-            if (detachRejected) {
-                let endpointSafe = false;
-                try {
-                    endpointSafe = serverEnvironmentAccess.endpointSafe(this.#environment, this.#attachment);
-                }
-                catch (error) {
-                    CloseErrors.collect(error, detachErrors);
-                }
-                if (!endpointSafe) {
-                    ServerValues.throwRunningDetachErrors(detachErrors);
-                }
-            }
-        }
-        return { detachErrors, detachRejected };
-    }
     /**
      * Waits for every context's accepted work before any Stand closes.
      *
      * @returns Completion after all context work drains.
      */
     async #drainContexts() {
+        await this.#queries.drain();
         for (const context of this.#contexts)
             boundedContextAccess.beginClose(context);
         const drained = await Promise.allSettled(this.#contexts.map((context) => boundedContextAccess.drainWork(context)));
-        const drainErrors = drained.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        const delivery = await Promise.allSettled([
+            serverEnvironmentAccess.whenDeliveryIdle(this.#environment),
+        ]);
+        const drainErrors = [...drained, ...delivery].flatMap((result) => result.status === "rejected" ? [result.reason] : []);
         if (drainErrors.length > 0) {
             throw new AggregateError(drainErrors, "Server close failed while draining contexts.");
         }
@@ -859,17 +825,17 @@ const ServerValues = Object.freeze({
         });
     },
     /**
-     * Collects attachment and immediate cleanup failures for startup reporting.
+     * Collects route registration and immediate cleanup failures for startup reporting.
      *
-     * @param startError Attachment or duplicate registration failure.
+     * @param startError Route or duplicate registration failure.
      * @param cleanupError Failure while closing prepared resources.
      * @returns Both failures in one AggregateError.
      */
-    attachmentCleanupError(startError, cleanupError) {
+    registrationCleanupError(startError, cleanupError) {
         const errors = [];
         CloseErrors.collect(startError, errors);
         CloseErrors.collect(cleanupError, errors);
-        return new AggregateError(errors, "Server attachment failed and immediate dependency cleanup also failed.");
+        return new AggregateError(errors, "Server registration failed and immediate dependency cleanup also failed.");
     },
     /**
      * Throws one deferred cleanup failure or groups several.
@@ -901,18 +867,6 @@ const ServerValues = Object.freeze({
         }
         throw new AggregateError(errors, "Server start failed while opening listener and cleanup also failed.");
     },
-    /**
-     * Throws one delivery-detachment error or groups several.
-     *
-     * @param errors Delivery-detachment failures.
-     * @returns Never; this method throws.
-     */
-    throwRunningDetachErrors(errors) {
-        if (errors.length === 1) {
-            throw errors[0];
-        }
-        throw new AggregateError(errors, "Server close failed while detaching delivery.");
-    },
     /**
      * Closes the HTTP/2 server and all tracked sessions.
      *