@rlanz/socket 0.0.1-9 → 0.1.0

package/build/providers/socket_provider.js

@@ -1,3 +1,6 @@
+import {
+  SERVER_DISCONNECT_CODE
+} from "../chunk-YSW4MNFR.js";
 import {
   BaseChannel,
   SocketResponseError
@@ -13,7 +16,7 @@ import {
   disconnectChannel,
   subscribeChannel,
   unsubscribeChannel
-} from "../chunk-D3HUBCBW.js";
+} from "../chunk-NUPBNOP3.js";
 import {
   SocketFake
 } from "../chunk-IUQ3GYZZ.js";
@@ -138,7 +141,7 @@ var ChannelSubscriptions = class _ChannelSubscriptions {
       };
     }
     if (this.#usesPresence(result.instance)) {
-      return this.#withChannelOperation(channelName, async () => {
+      return this.#withChannelOperation(`${socket.id}\0${channelName}`, async () => {
         const concurrentSubscription = await this.#refreshExistingSubscription(socket, channelName);
         if (concurrentSubscription) {
           return concurrentSubscription;
@@ -162,17 +165,13 @@ var ChannelSubscriptions = class _ChannelSubscriptions {
     try {
       if (this.#usesPresence(result.instance)) {
         const presenceInfo = result.instance.$getPresenceInfo(socket);
-        const wasPresent = (await this.presenceManager.snapshot(channelName)).users.some(
-          (user) => user.id === presenceInfo.id
-        );
-        const { joinedAt: _joinedAt, ...member } = this.presenceManager.join(
-          channelName,
-          socket.raw,
-          presenceInfo
-        );
+        const joinedUser = this.presenceManager.join(channelName, socket.raw, presenceInfo);
+        const { joinedAt: _joinedAt, ...member } = joinedUser;
         presenceJoined = true;
         presenceSnapshot = await this.presenceManager.snapshot(channelName);
         presenceData = presenceSnapshot;
+        const visibleUser = presenceSnapshot.users.find((user) => user.id === presenceInfo.id);
+        const wasPresent = Boolean(visibleUser && visibleUser !== joinedUser);
         try {
           JSON.stringify(presenceData);
         } catch (error) {
@@ -238,7 +237,7 @@ var ChannelSubscriptions = class _ChannelSubscriptions {
     this.#storage.delete(socket.id, channelName);
     if (this.#usesPresence(subscription.instance)) {
       await this.#withChannelOperation(
-        channelName,
+        `${socket.id}\0${channelName}`,
         () => this.#cleanupAfterLeave(socket, channelName, subscription)
       );
     } else {
@@ -328,18 +327,18 @@ var ChannelSubscriptions = class _ChannelSubscriptions {
     } catch {
     }
   }
-  async #withChannelOperation(channelName, operation) {
-    const previous = this.#channelOperations.get(channelName) ?? Promise.resolve();
+  async #withChannelOperation(operationKey, operation) {
+    const previous = this.#channelOperations.get(operationKey) ?? Promise.resolve();
     const release = Promise.withResolvers();
     const queued = previous.then(() => release.promise);
-    this.#channelOperations.set(channelName, queued);
+    this.#channelOperations.set(operationKey, queued);
     await previous;
     try {
       return await operation();
     } finally {
       release.resolve();
-      if (this.#channelOperations.get(channelName) === queued) {
-        this.#channelOperations.delete(channelName);
+      if (this.#channelOperations.get(operationKey) === queued) {
+        this.#channelOperations.delete(operationKey);
       }
     }
   }
@@ -393,17 +392,17 @@ var ChannelSubscriptions = class _ChannelSubscriptions {
 // src/protocol/reply.ts
 var INVALID_SOCKET_MESSAGE = "Invalid socket message";
 var Reply = class _Reply {
-  constructor(id, ok, data, error) {
-    this.id = id;
-    this.ok = ok;
-    this.data = data;
-    this.error = error;
+  #id;
+  #ack;
+  constructor(id, ack) {
+    this.#id = id;
+    this.#ack = ack;
   }
   static ok(id, data) {
-    return new _Reply(id, true, data, void 0);
+    return new _Reply(id, { ok: true, data });
   }
   static error(id, error) {
-    return new _Reply(id, false, void 0, error);
+    return new _Reply(id, { ok: false, error });
   }
   static invalidMessage(id) {
     if (id === void 0) {
@@ -416,7 +415,7 @@ var Reply = class _Reply {
       return _Reply.error(id, "Socket service is not initialized");
     }
     if (!result.ack.ok) {
-      return _Reply.error(id, result.ack.error ?? "Subscribe failed");
+      return _Reply.error(id, result.ack.error);
     }
     const data = result.ack.presenceData ? {
       presenceData: result.ack.presenceData
@@ -424,21 +423,18 @@ var Reply = class _Reply {
     return _Reply.ok(id, data);
   }
   static fromChannelAck(id, ack) {
-    return ack.ok ? _Reply.ok(id, ack.data) : _Reply.error(id, ack.error ?? "Handler error");
+    return ack.ok ? _Reply.ok(id, ack.data) : _Reply.error(id, ack.error);
   }
   toFrame() {
-    const frame = {
-      id: this.id,
-      type: "ack",
-      ok: this.ok
-    };
-    if (this.data !== void 0) {
-      frame.data = this.data;
-    }
-    if (this.error !== void 0) {
-      frame.error = this.error;
+    if (!this.#ack.ok) {
+      return {
+        id: this.#id,
+        type: "ack",
+        ok: false,
+        error: this.#ack.error
+      };
     }
-    return frame;
+    return this.#ack.data === void 0 ? { id: this.#id, type: "ack", ok: true } : { id: this.#id, type: "ack", ok: true, data: this.#ack.data };
   }
 };
 
@@ -1126,10 +1122,34 @@ var DEFAULT_MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024;
 var DEFAULT_MAX_OUTBOUND_PAYLOAD = 1024 * 1024;
 var DEFAULT_MAX_SUBSCRIPTIONS_PER_SOCKET = 100;
 var DEFAULT_MAX_CHANNEL_NAME_LENGTH = 255;
+var DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
 var CLOSE_POLICY_VIOLATION = 1008;
 var CLOSE_MESSAGE_TOO_BIG = 1009;
 var CLOSE_OUTBOUND_BUFFER_LIMIT = "Socket outbound buffer limit exceeded";
 var CLOSE_OUTBOUND_MESSAGE_TOO_BIG = "Socket outbound message too big";
+var SERVER_DISCONNECT_REASON = "Socket server disconnected";
+async function settleBeforeDeadline(promise, deadline) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) {
+    void promise.catch(() => {
+    });
+    return null;
+  }
+  let timer;
+  try {
+    return await Promise.race([
+      promise.then(
+        (value) => ({ status: "fulfilled", value }),
+        (reason) => ({ status: "rejected", reason })
+      ),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), remaining);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function serializeFrame(frame) {
   return JSON.stringify(frame);
 }
@@ -1232,13 +1252,8 @@ function closeConnection(connection, code, reason) {
   }
 }
 var SocketService = class extends Emittery {
-  #server = null;
-  #httpServer = null;
-  #upgradeHandler = null;
   #sockets = /* @__PURE__ */ new Map();
-  #channelSubscriptions = null;
   #presenceManager = null;
-  #bus = null;
   #fake = null;
   #deliverySink = {
     dispatch: (emission) => {
@@ -1246,49 +1261,113 @@ var SocketService = class extends Emittery {
     }
   };
   #broadcastSink = this.#deliverySink;
-  #status = "stopped";
-  #lastError = null;
+  #lifecycle = { status: "stopped" };
   #heartbeatInterval = null;
   #heartbeatTimeouts = /* @__PURE__ */ new Map();
   #messageQueue = new MessageQueue();
   #messageRates = /* @__PURE__ */ new Map();
   #socketFinalizations = /* @__PURE__ */ new Map();
-  #closePromise = null;
   #outboundMessageConfig = resolveOutboundMessageConfig(void 0);
+  #shutdownTimeout = DEFAULT_SHUTDOWN_TIMEOUT;
   #logger = null;
   /**
    * Accesses the underlying ws server.
    */
   get server() {
-    if (!this.#server) {
+    const runtime = this.#runtime;
+    if (!runtime) {
       throw new Error("WebSocket server is not initialized. Call boot() first.");
     }
-    return this.#server;
+    return runtime.server;
+  }
+  get #resources() {
+    switch (this.#lifecycle.status) {
+      case "starting":
+        return this.#lifecycle.operation;
+      case "ready":
+        return this.#lifecycle.runtime;
+      case "stopping":
+      case "failed":
+        return this.#lifecycle.resources;
+      case "stopped":
+        return void 0;
+    }
+  }
+  get #runtime() {
+    if (this.#lifecycle.status === "ready") return this.#lifecycle.runtime;
+    if (this.#lifecycle.status !== "failed") return void 0;
+    const resources = this.#lifecycle.resources;
+    if (!resources) return void 0;
+    if (resources.kind === "runtime") return resources;
+    return resources.runtime;
+  }
+  get #channelSubscriptions() {
+    const resources = this.#resources;
+    if (!resources) return void 0;
+    if (resources.kind === "runtime") return resources.channelSubscriptions;
+    return resources.runtime?.channelSubscriptions ?? resources.channelSubscriptions;
+  }
+  get #bus() {
+    const resources = this.#resources;
+    if (!resources) return void 0;
+    if (resources.kind === "runtime") return resources.bus;
+    return resources.runtime?.bus ?? resources.bus;
+  }
+  #isStarting(operation) {
+    return this.#lifecycle.status === "starting" && this.#lifecycle.operation === operation;
+  }
+  #closeBootBusAfterStart(operation) {
+    const bus = operation.bus;
+    if (!bus) return Promise.resolve();
+    if (operation.busCloseAfterStart) return operation.busCloseAfterStart;
+    const close = bus.close();
+    operation.busCloseAfterStart = close;
+    return close;
   }
   setPresenceManager(presenceManager) {
     this.#presenceManager = presenceManager;
     this.#channelSubscriptions?.setPresenceManager(presenceManager);
-    this.#configurePresenceFetcher();
+    this.#configurePresenceFetcher(this.#bus);
   }
-  async boot(httpServer, config, channelRouter, logger, runWithHttpContext) {
-    this.#closePromise = null;
-    this.#status = "starting";
-    this.#lastError = null;
+  boot(httpServer, config, channelRouter, logger, runWithHttpContext) {
+    if (this.#lifecycle.status === "ready") return Promise.resolve();
+    if (this.#lifecycle.status === "starting") return this.#lifecycle.operation.promise;
+    if (this.#lifecycle.status === "stopping") {
+      return Promise.reject(new Error("Socket service is stopping"));
+    }
+    if (this.#lifecycle.status === "failed" && this.#lifecycle.resources) {
+      return Promise.reject(new Error("Socket service must be closed before rebooting"));
+    }
     this.#logger = logger;
-    const websocketConfig = config.websocket;
-    const heartbeatConfig = resolveHeartbeatConfig(websocketConfig);
-    const inboundMessageConfig = resolveInboundMessageConfig(websocketConfig);
-    this.#outboundMessageConfig = resolveOutboundMessageConfig(websocketConfig);
-    this.#channelSubscriptions = new ChannelSubscriptions(
-      this,
-      channelRouter,
-      logger,
-      this.#presenceManager ?? void 0,
-      inboundMessageConfig.subscriptionLimits
+    const deferred = Promise.withResolvers();
+    const operation = {
+      kind: "boot",
+      promise: deferred.promise,
+      closeRequested: false
+    };
+    this.#lifecycle = { status: "starting", operation };
+    void this.#boot(httpServer, config, channelRouter, logger, runWithHttpContext, operation).then(
+      deferred.resolve,
+      deferred.reject
     );
+    return operation.promise;
+  }
+  async #boot(httpServer, config, channelRouter, logger, runWithHttpContext, operation) {
     try {
+      const websocketConfig = config.websocket;
+      const heartbeatConfig = resolveHeartbeatConfig(websocketConfig);
+      const inboundMessageConfig = resolveInboundMessageConfig(websocketConfig);
+      this.#outboundMessageConfig = resolveOutboundMessageConfig(websocketConfig);
+      this.#shutdownTimeout = parseDuration("websocket.shutdownTimeout", websocketConfig?.shutdownTimeout) ?? DEFAULT_SHUTDOWN_TIMEOUT;
+      operation.channelSubscriptions = new ChannelSubscriptions(
+        this,
+        channelRouter,
+        logger,
+        this.#presenceManager ?? void 0,
+        inboundMessageConfig.subscriptionLimits
+      );
       if (config.transport) {
-        this.#bus = new SocketBus(config.transport, {
+        operation.bus = new SocketBus(config.transport, {
           channel: (message) => {
             this.#traceBroadcast(
               {
@@ -1316,22 +1395,22 @@ var SocketService = class extends Emittery {
             return this.#getLocalPresenceSockets(channel);
           }
         });
-        await this.#bus.start();
-        this.#configurePresenceFetcher();
+        await operation.bus.start();
+        if (!this.#isStarting(operation)) {
+          throw new Error("Socket service boot interrupted by shutdown");
+        }
       }
       const websocketServer = new WebSocketServer({
         noServer: true,
         maxPayload: inboundMessageConfig.maxPayload
       });
-      this.#server = websocketServer;
-      this.#httpServer = httpServer;
       const upgrader = new SocketUpgrader(
         websocketServer,
         websocketConfig,
         runWithHttpContext,
         (message, error) => this.#warn(message, error)
       );
-      this.#upgradeHandler = (request, socket, head) => {
+      const upgradeHandler = (request, socket, head) => {
         upgrader.handle(request, socket, head, (connection, upgradeRequest, accepted) => {
           this.#handleConnection(connection, upgradeRequest, accepted, inboundMessageConfig);
         }).catch((error) => {
@@ -1339,18 +1418,40 @@ var SocketService = class extends Emittery {
           SocketUpgrader.reject(socket, 500, "Internal Server Error");
         });
       };
-      httpServer.on("upgrade", this.#upgradeHandler);
+      const runtime = {
+        kind: "runtime",
+        server: websocketServer,
+        httpServer,
+        upgradeHandler,
+        channelSubscriptions: operation.channelSubscriptions,
+        bus: operation.bus ?? null
+      };
+      operation.runtime = runtime;
+      httpServer.on("upgrade", upgradeHandler);
       this.#startHeartbeat(heartbeatConfig);
-      this.#status = "ready";
+      if (!this.#isStarting(operation)) {
+        throw new Error("Socket service boot interrupted by shutdown");
+      }
+      this.#lifecycle = { status: "ready", runtime };
+      this.#configurePresenceFetcher(runtime.bus);
     } catch (error) {
-      this.#lastError = error instanceof Error ? error : new Error("Socket service boot failed");
-      this.#status = "failed";
+      if (!this.#isStarting(operation)) {
+        if (operation.closeRequested) {
+          await this.#closeBootBusAfterStart(operation);
+        }
+        if (this.#lifecycle.status === "failed" && this.#lifecycle.resources === operation && !this.#lifecycle.close) {
+          await this.close();
+        }
+        throw error;
+      }
+      const failure = error instanceof Error ? error : new Error("Socket service boot failed");
+      this.#lifecycle = { status: "failed", error: failure, resources: operation };
       await this.close();
       throw error;
     }
   }
   #handleConnection(connection, request, upgrade, inboundMessageConfig) {
-    if (this.#status !== "ready") {
+    if (this.#lifecycle.status !== "ready") {
       connection.terminate();
       return;
     }
@@ -1418,21 +1519,22 @@ var SocketService = class extends Emittery {
     if (!this.#sockets.has(socket.id)) {
       return Promise.resolve();
     }
+    const channelSubscriptions = this.#channelSubscriptions;
     const finalization = disconnectChannel.tracePromise(
       async () => {
         this.#clearHeartbeatTimeout(socket.id);
         this.#messageRates.delete(socket.id);
         await this.#messageQueue.drain(socket.id);
         this.#messageQueue.delete(socket.id);
-        await this.#channelSubscriptions?.leaveAll(socket);
-        this.#channelSubscriptions?.deleteSocket(socket.id);
+        await channelSubscriptions?.leaveAll(socket);
+        channelSubscriptions?.deleteSocket(socket.id);
         this.#sockets.delete(socket.id);
         this.#emitLifecycleEvent("disconnect", { socket, reason: "close" });
       },
       {
         socketId: socket.id,
         reason: "close",
-        subscriptions: this.#channelSubscriptions?.subscriptionCountFor(socket.id) ?? 0
+        subscriptions: channelSubscriptions?.subscriptionCountFor(socket.id) ?? 0
       }
     ).finally(() => {
       this.#socketFinalizations.delete(socket.id);
@@ -1479,7 +1581,9 @@ var SocketService = class extends Emittery {
         await unsubscribeChannel.tracePromise(async () => {
           traceMessage.removed = await this.#channelSubscriptions?.leave(socket, message.channel) ?? false;
           traceMessage.ok = true;
-          this.#emitLifecycleEvent("unsubscribe", { socket, channel: message.channel });
+          if (traceMessage.removed) {
+            this.#emitLifecycleEvent("unsubscribe", { socket, channel: message.channel });
+          }
           sendFrame(
             socket.raw.connection,
             Reply.ok(message.id).toFrame(),
@@ -1506,7 +1610,7 @@ var SocketService = class extends Emittery {
       const ack = await this.#handleChannelPayload(socket, message.type, payload);
       traceMessage.ok = ack.ok;
       if (!ack.ok) {
-        traceMessage.error = ack.error ?? "Handler error";
+        traceMessage.error = ack.error;
       }
       sendFrame(
         socket.raw.connection,
@@ -1545,7 +1649,7 @@ var SocketService = class extends Emittery {
         this.#sendSerializedEventFrame(connection, serializeFrame({ type: "event", event, data }));
       },
       disconnect() {
-        connection.close();
+        connection.close(SERVER_DISCONNECT_CODE, SERVER_DISCONNECT_REASON);
       },
       raw
     };
@@ -1651,14 +1755,14 @@ var SocketService = class extends Emittery {
     }
     return delivered;
   }
-  #configurePresenceFetcher() {
-    if (!this.#presenceManager || !this.#bus) {
+  #configurePresenceFetcher(bus) {
+    if (!this.#presenceManager || !bus) {
       return;
     }
     this.#presenceManager.setSocketFetcher(async (channel) => {
       return [
         ...this.#presenceManager.getLocalSockets(channel),
-        ...await this.#bus.fetchPresenceSockets(channel)
+        ...await bus.fetchPresenceSockets(channel)
       ];
     });
   }
@@ -1674,10 +1778,10 @@ var SocketService = class extends Emittery {
     return this.#sockets.size;
   }
   get status() {
-    return this.#status;
+    return this.#lifecycle.status;
   }
   get ready() {
-    return this.#status === "ready" && Boolean(this.#server);
+    return this.#lifecycle.status === "ready";
   }
   fake() {
     const fake = new SocketFake(() => {
@@ -1694,8 +1798,21 @@ var SocketService = class extends Emittery {
     this.#broadcastSink = this.#deliverySink;
   }
   markFailed(error) {
-    this.#lastError = error instanceof Error ? error : new Error("Socket service failed");
-    this.#status = "failed";
+    const failure = error instanceof Error ? error : new Error("Socket service failed");
+    const lifecycle = this.#lifecycle;
+    if (lifecycle.status === "stopped") {
+      this.#lifecycle = { status: "failed", error: failure };
+      return;
+    }
+    if (lifecycle.status === "starting") {
+      this.#lifecycle = { status: "failed", error: failure, resources: lifecycle.operation };
+      return;
+    }
+    if (lifecycle.status === "ready") {
+      this.#lifecycle = { status: "failed", error: failure, resources: lifecycle.runtime };
+      return;
+    }
+    this.#lifecycle = { ...lifecycle, status: "failed", error: failure };
   }
   #warn(message, error) {
     try {
@@ -1712,12 +1829,13 @@ var SocketService = class extends Emittery {
     });
   }
   health() {
+    const error = this.#lifecycle.status === "failed" ? this.#lifecycle.error : void 0;
     return {
-      status: this.#status,
+      status: this.#lifecycle.status,
       ready: this.ready,
       connections: this.#sockets.size,
       channels: this.#channelSubscriptions?.channelsCount ?? 0,
-      ...this.#lastError ? { lastError: this.#lastError.message } : {}
+      ...error ? { lastError: error.message } : {}
     };
   }
   #startHeartbeat(config) {
@@ -1783,72 +1901,136 @@ var SocketService = class extends Emittery {
     rate.count += 1;
     return true;
   }
-  #cleanup() {
+  #cleanup(channelSubscriptions) {
     this.#stopHeartbeat();
     this.#sockets.clear();
     this.#messageQueue.clear();
     this.#messageRates.clear();
     this.#socketFinalizations.clear();
-    this.#channelSubscriptions?.clear();
+    channelSubscriptions?.clear();
   }
   close() {
-    if (!this.#closePromise) {
-      this.#closePromise = this.#close();
-    }
-    return this.#closePromise;
-  }
-  async #close() {
-    const server = this.#server;
-    const bus = this.#bus;
-    const httpServer = this.#httpServer;
-    const upgradeHandler = this.#upgradeHandler;
-    if (this.#status !== "failed") {
-      this.#status = "stopping";
-    }
-    this.#server = null;
-    this.#httpServer = null;
-    this.#upgradeHandler = null;
-    if (httpServer && upgradeHandler) {
-      httpServer.off("upgrade", upgradeHandler);
+    const lifecycle = this.#lifecycle;
+    if (lifecycle.status === "stopped") return Promise.resolve();
+    if (lifecycle.status === "stopping") return lifecycle.close;
+    if (lifecycle.status === "failed" && lifecycle.close) return lifecycle.close;
+    if (lifecycle.status === "failed" && !lifecycle.resources) return Promise.resolve();
+    if (lifecycle.status === "starting") {
+      return this.#startClose(lifecycle.operation, lifecycle.operation.promise);
+    }
+    if (lifecycle.status === "ready") return this.#startClose(lifecycle.runtime);
+    return this.#startClose(lifecycle.resources, void 0, lifecycle.error);
+  }
+  #startClose(resources, pendingBoot, preservedError) {
+    const deferred = Promise.withResolvers();
+    const close = deferred.promise;
+    if (resources.kind === "boot") resources.closeRequested = true;
+    this.#lifecycle = preservedError ? { status: "failed", error: preservedError, resources, close } : { status: "stopping", resources, close };
+    void this.#close(resources, pendingBoot).then(
+      () => {
+        if (!("close" in this.#lifecycle) || this.#lifecycle.close !== close) return;
+        this.#lifecycle = this.#lifecycle.status === "failed" ? { status: "failed", error: this.#lifecycle.error, close } : { status: "stopped" };
+        deferred.resolve();
+      },
+      (error) => {
+        const failure = error instanceof Error ? error : new Error("Socket service shutdown failed");
+        if ("close" in this.#lifecycle && this.#lifecycle.close === close) {
+          this.#lifecycle = { status: "failed", error: failure, close };
+        }
+        deferred.reject(error);
+      }
+    );
+    return close;
+  }
+  async #waitForBootClose(pendingBoot, deadline) {
+    const result = await settleBeforeDeadline(pendingBoot, deadline);
+    if (result === null) {
+      this.#warn(
+        "socket boot exceeded the %dms shutdown timeout; forcing cleanup",
+        this.#shutdownTimeout
+      );
     }
-    const serverClose = server ? new Promise((resolve) => {
+  }
+  #startServerClose(server) {
+    if (!server) return Promise.resolve(null);
+    return new Promise((resolve) => {
       server.close((error) => resolve(error ?? null));
-    }) : Promise.resolve(null);
+    });
+  }
+  async #closeSockets(deadline) {
     this.#stopHeartbeat();
     const sockets = [...this.#sockets.values()];
     for (const socket of sockets) {
-      socket.raw.connection.terminate();
+      const { connection } = socket.raw;
+      connection.close(SERVER_DISCONNECT_CODE, SERVER_DISCONNECT_REASON);
+      const terminateTimer = setTimeout(() => connection.terminate(), 50);
+      connection.once("close", () => clearTimeout(terminateTimer));
     }
-    const errors = [];
     const finalizations = sockets.map((socket) => {
       return Promise.resolve().then(() => this.#finalizeSocket(socket));
     });
-    const results = await Promise.allSettled(finalizations);
-    for (const result of results) {
-      if (result.status === "rejected") {
-        errors.push(result.reason);
-      }
+    const results = await settleBeforeDeadline(Promise.allSettled(finalizations), deadline);
+    if (results === null) {
+      this.#warn(
+        "socket finalization exceeded the %dms shutdown timeout; forcing cleanup",
+        this.#shutdownTimeout
+      );
+      return [];
     }
-    this.#cleanup();
-    this.#presenceManager?.setSocketFetcher(null);
-    this.#bus = null;
-    try {
-      await bus?.close();
-    } catch (error) {
-      errors.push(error);
+    if (results.status === "rejected") return [];
+    const errors = [];
+    for (const result of results.value) {
+      if (result.status === "rejected") errors.push(result.reason);
     }
-    const serverCloseError = await serverClose;
-    if (serverCloseError) {
-      errors.push(serverCloseError);
+    return errors;
+  }
+  async #closeBus(resources, bus, deadline) {
+    if (!bus) return [];
+    const close = resources.kind === "boot" ? resources.busCloseAfterStart ?? (resources.busCloseBeforeStart ??= bus.close()) : bus.close();
+    const result = await settleBeforeDeadline(close, deadline);
+    if (result === null) {
+      this.#warn(
+        "socket transport exceeded the %dms shutdown timeout; forcing cleanup",
+        this.#shutdownTimeout
+      );
+      return [];
     }
+    return result.status === "rejected" ? [result.reason] : [];
+  }
+  async #finishServerClose(close, deadline) {
+    const result = await settleBeforeDeadline(close, deadline);
+    if (result === null) {
+      this.#warn(
+        "socket server exceeded the %dms shutdown timeout; forcing cleanup",
+        this.#shutdownTimeout
+      );
+      return [];
+    }
+    if (result.status === "rejected" || !result.value) return [];
+    return [result.value];
+  }
+  async #close(resources, pendingBoot) {
+    const deadline = Date.now() + this.#shutdownTimeout;
+    if (pendingBoot) await this.#waitForBootClose(pendingBoot, deadline);
+    const runtime = resources.kind === "runtime" ? resources : resources.runtime;
+    const channelSubscriptions = runtime?.channelSubscriptions ?? (resources.kind === "boot" ? resources.channelSubscriptions : void 0);
+    const server = runtime?.server;
+    const bus = runtime?.bus ?? (resources.kind === "boot" ? resources.bus : void 0);
+    const httpServer = runtime?.httpServer;
+    const upgradeHandler = runtime?.upgradeHandler;
+    if (httpServer && upgradeHandler) {
+      httpServer.off("upgrade", upgradeHandler);
+    }
+    const serverClose = this.#startServerClose(server);
+    const errors = await this.#closeSockets(deadline);
+    this.#cleanup(channelSubscriptions);
+    this.#presenceManager?.setSocketFetcher(null);
+    errors.push(...await this.#closeBus(resources, bus, deadline));
+    errors.push(...await this.#finishServerClose(serverClose, deadline));
     if (errors.length > 0) {
       const error = errors.length === 1 && errors[0] instanceof Error ? errors[0] : new AggregateError(errors, "Socket service shutdown failed");
-      this.markFailed(error);
       throw error;
     }
-    if (this.#status !== "failed") {
-      this.#status = "stopped";
-    }
   }
 };