@moxt-ai/mobius 0.0.301 → 0.0.303

package/dist/cli.js

@@ -2086,7 +2086,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@moxt-ai/mobius",
-      version: "0.0.301",
+      version: "0.0.303",
       description: "Mobius CLI for pairing and running local AI agent services.",
       type: "module",
       bin: {
@@ -72906,6 +72906,46 @@ var init_access = __esm({
   }
 });
 
+// ../mobius-sdk/src/protocol/session/agent/catalog.ts
+var AGENT_CATALOG_DISCOVER_KIND, AGENT_CATALOG_DISCOVERED_KIND, AGENT_CATALOG_DISCOVERY_FAILED_KIND, catalogedAgentSchema, agentCatalogDiscoverCommandSchema, agentCatalogDiscoveredEventSchema, agentCatalogDiscoveryFailedEventSchema, decodeAgentCatalogDiscoverCommand, encodeAgentCatalogDiscoverCommand, decodeAgentCatalogDiscoveredEvent, encodeAgentCatalogDiscoveredEvent, decodeAgentCatalogDiscoveryFailedEvent, encodeAgentCatalogDiscoveryFailedEvent;
+var init_catalog = __esm({
+  "../mobius-sdk/src/protocol/session/agent/catalog.ts"() {
+    "use strict";
+    init_zod();
+    init_identifier();
+    init_message_codec();
+    AGENT_CATALOG_DISCOVER_KIND = "agent.catalog.discover";
+    AGENT_CATALOG_DISCOVERED_KIND = "agent.catalog.discovered";
+    AGENT_CATALOG_DISCOVERY_FAILED_KIND = "agent.catalog.discovery.failed";
+    catalogedAgentSchema = external_exports.object({
+      agentVersion: external_exports.string().min(1).max(128),
+      id: identifierStringSchema,
+      label: external_exports.string().min(1).max(255)
+    }).readonly();
+    agentCatalogDiscoverCommandSchema = external_exports.object({
+      kind: external_exports.literal(AGENT_CATALOG_DISCOVER_KIND),
+      requestId: identifierStringSchema
+    }).readonly();
+    agentCatalogDiscoveredEventSchema = external_exports.object({
+      agents: external_exports.array(catalogedAgentSchema).max(64).readonly(),
+      kind: external_exports.literal(AGENT_CATALOG_DISCOVERED_KIND),
+      requestId: identifierStringSchema
+    }).readonly();
+    agentCatalogDiscoveryFailedEventSchema = external_exports.object({
+      code: identifierStringSchema,
+      kind: external_exports.literal(AGENT_CATALOG_DISCOVERY_FAILED_KIND),
+      message: external_exports.string().min(1).max(500),
+      requestId: identifierStringSchema
+    }).readonly();
+    decodeAgentCatalogDiscoverCommand = (encoded) => decodeZodMessage(encoded, agentCatalogDiscoverCommandSchema);
+    encodeAgentCatalogDiscoverCommand = (message) => encodeZodMessage(message, agentCatalogDiscoverCommandSchema);
+    decodeAgentCatalogDiscoveredEvent = (encoded) => decodeZodMessage(encoded, agentCatalogDiscoveredEventSchema);
+    encodeAgentCatalogDiscoveredEvent = (message) => encodeZodMessage(message, agentCatalogDiscoveredEventSchema);
+    decodeAgentCatalogDiscoveryFailedEvent = (encoded) => decodeZodMessage(encoded, agentCatalogDiscoveryFailedEventSchema);
+    encodeAgentCatalogDiscoveryFailedEvent = (message) => encodeZodMessage(message, agentCatalogDiscoveryFailedEventSchema);
+  }
+});
+
 // ../mobius-sdk/src/protocol/session/shared/index.ts
 var SHORT_TEXT, workspaceEntrySchema, sessionStatusSchema, sessionCapabilitiesSchema, sessionCommandSchema, configValueSchema, sessionIdentityFields;
 var init_shared2 = __esm({
@@ -74859,6 +74899,7 @@ var init_daemon_transport = __esm({
     init_diagnostics();
     init_liveness();
     init_upgrade();
+    init_catalog();
     init_settings2();
     init_configuration();
     init_title();
@@ -74882,6 +74923,11 @@ var init_daemon_transport = __esm({
         encodeAgentSettingsDiscoverCommand,
         decodeAgentSettingsDiscoverCommand
       ),
+      [AGENT_CATALOG_DISCOVER_KIND]: defineMessageSignature(
+        AGENT_CATALOG_DISCOVER_KIND,
+        encodeAgentCatalogDiscoverCommand,
+        decodeAgentCatalogDiscoverCommand
+      ),
       [FILE_READ_KIND]: defineMessageSignature(FILE_READ_KIND, encodeFileReadCommand, decodeFileReadCommand),
       [SESSION_LIST_KIND]: defineMessageSignature(SESSION_LIST_KIND, encodeSessionListCommand, decodeSessionListCommand),
       [SESSION_QUERY_KIND]: defineMessageSignature(
@@ -75023,6 +75069,16 @@ var init_daemon_transport = __esm({
         encodeAgentSettingsDiscoveryFailedEvent,
         decodeAgentSettingsDiscoveryFailedEvent
       ),
+      [AGENT_CATALOG_DISCOVERED_KIND]: defineMessageSignature(
+        AGENT_CATALOG_DISCOVERED_KIND,
+        encodeAgentCatalogDiscoveredEvent,
+        decodeAgentCatalogDiscoveredEvent
+      ),
+      [AGENT_CATALOG_DISCOVERY_FAILED_KIND]: defineMessageSignature(
+        AGENT_CATALOG_DISCOVERY_FAILED_KIND,
+        encodeAgentCatalogDiscoveryFailedEvent,
+        decodeAgentCatalogDiscoveryFailedEvent
+      ),
       [FILE_BEGIN_KIND]: defineMessageSignature(FILE_BEGIN_KIND, encodeFileBeginEvent, decodeFileBeginEvent),
       [FILE_CHUNK_KIND]: defineMessageSignature(FILE_CHUNK_KIND, encodeFileChunkEvent, decodeFileChunkEvent),
       [FILE_END_KIND]: defineMessageSignature(FILE_END_KIND, encodeFileEndEvent, decodeFileEndEvent),
@@ -75108,6 +75164,7 @@ var init_protocol = __esm({
     init_liveness();
     init_upgrade();
     init_access();
+    init_catalog();
     init_settings2();
     init_configuration();
     init_title();
@@ -75721,7 +75778,11 @@ var init_agent = __esm({
           const decoded = threadListResponseSchema.parse(
             await this.#appServer.request(
               "thread/list",
-              { cursor: context.params.cursor ?? null },
+              {
+                cursor: context.params.cursor ?? null,
+                // Codex defaults to interactive sources and otherwise hides exec handoffs.
+                sourceKinds: ["cli", "vscode", "exec", "appServer"]
+              },
               AbortSignal.any([context.signal, AbortSignal.timeout(SESSION_LIST_TIMEOUT_MILLISECONDS2)])
             )
           );
@@ -81006,6 +81067,7 @@ var init_discover_local_agents = __esm({
     init_supported_agent_specifications();
     init_agent_discovery();
     init_executable_discovery();
+    init_agent_discovery();
   }
 });
 
@@ -81186,12 +81248,33 @@ var init_publish_agent_catalog = __esm({
   }
 });
 
+// src/util/serial-task-queue.ts
+var SerialTaskQueue;
+var init_serial_task_queue = __esm({
+  "src/util/serial-task-queue.ts"() {
+    "use strict";
+    SerialTaskQueue = class {
+      #tail = Promise.resolve();
+      run = async (task, signal) => {
+        signal.throwIfAborted();
+        const result = this.#tail.then(() => {
+          signal.throwIfAborted();
+          return task(signal);
+        });
+        this.#tail = result.catch(() => void 0);
+        return await result;
+      };
+    };
+  }
+});
+
 // src/agent/catalog.ts
 var LocalAgentCatalogSnapshot, LocalAgentCatalogError, LocalAgentCatalog;
-var init_catalog = __esm({
+var init_catalog2 = __esm({
   "src/agent/catalog.ts"() {
     "use strict";
     init_operation_error();
+    init_serial_task_queue();
     LocalAgentCatalogSnapshot = class {
       agents;
       constructor(agents) {
@@ -81206,6 +81289,7 @@ var init_catalog = __esm({
     };
     LocalAgentCatalog = class {
       #snapshot;
+      #updates = new SerialTaskQueue();
       constructor(agents) {
         this.#snapshot = this.validate(agents);
       }
@@ -81218,10 +81302,20 @@ var init_catalog = __esm({
         throw new LocalAgentCatalogError();
       };
       read = () => this.#snapshot;
-      transition = (agents) => {
-        const next = this.validate(agents);
-        this.#snapshot = next;
-        return next;
+      /** Serializes replacements and publication; a failed publication restores only its own prior snapshot. */
+      replaceAndPublish = async (build, publish, signal) => {
+        return await this.#updates.run(async (updateSignal) => {
+          const previous = this.#snapshot;
+          const next = this.validate(build(previous.agents));
+          this.#snapshot = next;
+          try {
+            await publish(updateSignal);
+          } catch (error62) {
+            this.#snapshot = previous;
+            throw error62;
+          }
+          return next;
+        }, signal);
       };
       validate = (agents) => {
         const identifiers = /* @__PURE__ */ new Set();
@@ -81252,7 +81346,7 @@ function withRuntimeEnvironment(agent, environment) {
   }
   return agent.withEnvironment({ ...launchEnvironment, ...agent.environment });
 }
-function createRuntimeConfig(connection, agents = [], localContext = new RuntimeLocalContext(readStateDirectory(), process.env), reconnectTarget = null, resolveAgent) {
+function createRuntimeConfig(connection, agents = [], localContext = new RuntimeLocalContext(readStateDirectory(), process.env), reconnectTarget = null, resolveAgent, rediscoverAgents) {
   const runtimeAgents = agents.map((agent) => withRuntimeEnvironment(agent, localContext.environment));
   return {
     agents: runtimeAgents,
@@ -81263,7 +81357,8 @@ function createRuntimeConfig(connection, agents = [], localContext = new Runtime
     localContext,
     reconnectTarget,
     relayUrl: connection.relayUrl,
-    ...resolveAgent === void 0 ? {} : { resolveAgent }
+    ...resolveAgent === void 0 ? {} : { resolveAgent },
+    ...rediscoverAgents === void 0 ? {} : { rediscoverAgents }
   };
 }
 var RuntimeLocalContext, RuntimeReconnectTarget, OpaqueRuntimeReconnectTarget;
@@ -81271,7 +81366,7 @@ var init_config = __esm({
   "src/runtime/config.ts"() {
     "use strict";
     init_protocol();
-    init_catalog();
+    init_catalog2();
     init_state_directory();
     RuntimeLocalContext = class {
       environment;
@@ -81321,21 +81416,17 @@ function createCatalogAgentResolver(discover, readConfig, publish) {
       signal.throwIfAborted();
       const inventory = await discover(signal);
       signal.throwIfAborted();
-      const previous = config2.catalog.read();
-      const previousAgent = previous.agents.find((entry) => entry.id === agent.id);
-      if (previousAgent === void 0) {
-        throw new Error(`The local Agent ${agent.id} left the catalog before its refresh completed`);
-      }
-      config2.catalog.transition([
-        ...previous.agents.filter((entry) => entry.id !== agent.id),
-        ...inventory.readyAgents().filter((ready) => ready.id === agent.id).map((ready) => withRuntimeEnvironment(ready, config2.localContext.environment))
-      ]);
-      try {
-        await publish(config2, signal);
-      } catch (error62) {
-        config2.catalog.transition(previous.agents);
-        throw error62;
-      }
+      const rediscovered = inventory.readyAgents().filter((ready) => ready.id === agent.id).map((ready) => withRuntimeEnvironment(ready, config2.localContext.environment));
+      await config2.catalog.replaceAndPublish(
+        (current) => {
+          if (!current.some((entry) => entry.id === agent.id)) {
+            throw new Error(`The local Agent ${agent.id} left the catalog before its refresh completed`);
+          }
+          return [...current.filter((entry) => entry.id !== agent.id), ...rediscovered];
+        },
+        (publishSignal) => publish(config2, publishSignal),
+        signal
+      );
       return config2.catalog.find(agent.id);
     } finally {
       swaps.delete(agent.id);
@@ -82526,7 +82617,12 @@ function buildPairedRuntime(installation, connection, defaultWorkspace, inventor
       }),
       () => config2,
       publishAgentCatalog
-    )
+    ),
+    (refreshSignal) => discoverLocalAgentInventory({
+      defaultWorkspace,
+      environment: localContext.environment,
+      signal: refreshSignal
+    }).then((inventory2) => inventory2.readyAgents())
   );
   return {
     channelUrl: new URL(`/channels/${encodeURIComponent(connection.channelId)}`, connection.relayOrigin).toString(),
@@ -97750,6 +97846,169 @@ var init_diagnostics2 = __esm({
   }
 });
 
+// src/runtime/command/transport.ts
+import { WebSocket as WebSocket2 } from "undici";
+function send(socket, message) {
+  if (socket.readyState !== WebSocket2.OPEN) {
+    throw new Error("Relay connection is not open");
+  }
+  socket.send(encodeDaemonToServiceMessage(message));
+}
+function reportOperationFailure(socket, requestId, sessionId, error62, runtimeTimings = []) {
+  if (socket.readyState !== WebSocket2.OPEN) {
+    return;
+  }
+  send(socket, {
+    code: operationErrorCode(error62),
+    kind: "session.operation.failed",
+    message: operationErrorMessage(error62),
+    requestId,
+    ...runtimeTimings.length === 0 ? {} : { runtimeTimings },
+    sessionId
+  });
+}
+var init_transport = __esm({
+  "src/runtime/command/transport.ts"() {
+    "use strict";
+    init_protocol();
+    init_operation_error();
+  }
+});
+
+// src/runtime/catalog/handle-agent-catalog-discovery.ts
+import { WebSocket as WebSocket3 } from "undici";
+function discoveredEvent(command, agents) {
+  return {
+    agents: agents.map((agent) => ({
+      agentVersion: agent.agentVersion,
+      id: agent.id,
+      label: agent.label
+    })),
+    kind: "agent.catalog.discovered",
+    requestId: command.requestId
+  };
+}
+function createAgentCatalogDiscoveryHandler(dependencies) {
+  const { config: config2, discover, diagnostics, socket, signal, timer } = dependencies;
+  const requestIds = /* @__PURE__ */ new Set();
+  let controller = null;
+  let completion = null;
+  const handle = (command) => {
+    if (requestIds.has(command.requestId) || controller !== null) {
+      if (socket.readyState === WebSocket3.OPEN) {
+        send(socket, {
+          code: "agent_catalog_discovery_busy",
+          kind: AGENT_CATALOG_DISCOVERY_FAILED_KIND,
+          message: "An Agent catalog discovery is already running",
+          requestId: command.requestId
+        });
+      }
+      return;
+    }
+    controller = new AbortController();
+    requestIds.add(command.requestId);
+    const operationSignal = AbortSignal.any([signal, controller.signal]);
+    const timeout = timer.schedule(
+      () => controller?.abort(new Error("Agent catalog discovery timed out")),
+      CATALOG_DISCOVERY_TIMEOUT_MILLISECONDS
+    );
+    completion = (async () => {
+      try {
+        const readyAgents = await discover(operationSignal);
+        operationSignal.throwIfAborted();
+        const published = await config2.catalog.replaceAndPublish(
+          () => readyAgents.map((agent) => withRuntimeEnvironment(agent, config2.localContext.environment)),
+          (publishSignal) => publishAgentCatalog(config2, publishSignal),
+          operationSignal
+        );
+        operationSignal.throwIfAborted();
+        if (socket.readyState === WebSocket3.OPEN) {
+          send(
+            socket,
+            discoveredEvent(
+              command,
+              published.agents.map((agent) => ({
+                agentVersion: agent.agentVersion,
+                id: agent.id,
+                label: agent.label
+              }))
+            )
+          );
+        }
+      } catch (error62) {
+        diagnostics.daemonDiagnostic(
+          "agent_catalog_discovery_failed",
+          command.requestId,
+          { code: operationErrorCode(error62) },
+          error62
+        );
+        if (socket.readyState === WebSocket3.OPEN) {
+          send(socket, {
+            code: operationErrorCode(error62),
+            kind: AGENT_CATALOG_DISCOVERY_FAILED_KIND,
+            message: operationErrorMessage(error62),
+            requestId: command.requestId
+          });
+        }
+      } finally {
+        timeout.cancel();
+        requestIds.delete(command.requestId);
+        controller = null;
+        completion = null;
+      }
+    })();
+  };
+  const settle2 = async () => {
+    await (completion ?? Promise.resolve());
+  };
+  return { handle, settle: settle2 };
+}
+var CATALOG_DISCOVERY_TIMEOUT_MILLISECONDS;
+var init_handle_agent_catalog_discovery = __esm({
+  "src/runtime/catalog/handle-agent-catalog-discovery.ts"() {
+    "use strict";
+    init_protocol();
+    init_operation_error();
+    init_transport();
+    init_config();
+    init_publish_agent_catalog();
+    CATALOG_DISCOVERY_TIMEOUT_MILLISECONDS = 9e4;
+  }
+});
+
+// src/runtime/command/registry/agent-catalog.ts
+function createAgentCatalogCommands(context) {
+  const handler = createAgentCatalogDiscoveryHandler({
+    config: context.config,
+    discover: context.config.rediscoverAgents === void 0 ? () => {
+      throw new Error("Agent catalog discovery is not available for this Runtime");
+    } : context.config.rediscoverAgents,
+    diagnostics: context.diagnostics,
+    socket: context.socket,
+    signal: context.signal,
+    timer: context.timer
+  });
+  return [
+    {
+      kind: AGENT_CATALOG_DISCOVER_KIND,
+      handle: (_context, message) => {
+        if (message.kind !== AGENT_CATALOG_DISCOVER_KIND) {
+          throw new Error("Command kind mismatch");
+        }
+        handler.handle(message);
+      },
+      settle: handler.settle
+    }
+  ];
+}
+var init_agent_catalog = __esm({
+  "src/runtime/command/registry/agent-catalog.ts"() {
+    "use strict";
+    init_protocol();
+    init_handle_agent_catalog_discovery();
+  }
+});
+
 // src/session/api/session-error.ts
 var SessionError;
 var init_session_error = __esm({
@@ -98123,37 +98382,8 @@ var init_discover_agent_settings = __esm({
   }
 });
 
-// src/runtime/command/transport.ts
-import { WebSocket as WebSocket2 } from "undici";
-function send(socket, message) {
-  if (socket.readyState !== WebSocket2.OPEN) {
-    throw new Error("Relay connection is not open");
-  }
-  socket.send(encodeDaemonToServiceMessage(message));
-}
-function reportOperationFailure(socket, requestId, sessionId, error62, runtimeTimings = []) {
-  if (socket.readyState !== WebSocket2.OPEN) {
-    return;
-  }
-  send(socket, {
-    code: operationErrorCode(error62),
-    kind: "session.operation.failed",
-    message: operationErrorMessage(error62),
-    requestId,
-    ...runtimeTimings.length === 0 ? {} : { runtimeTimings },
-    sessionId
-  });
-}
-var init_transport = __esm({
-  "src/runtime/command/transport.ts"() {
-    "use strict";
-    init_protocol();
-    init_operation_error();
-  }
-});
-
 // src/runtime/command/agent-settings-discovery.ts
-import { WebSocket as WebSocket3 } from "undici";
+import { WebSocket as WebSocket4 } from "undici";
 function createAgentSettingsDiscoveryHandler(dependencies) {
   const { config: config2, directories, sessions, diagnostics, socket, signal, timer } = dependencies;
   const agentSettingsDiscoveries = /* @__PURE__ */ new Map();
@@ -98162,7 +98392,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
       (request) => request.agentId === command.agentId && !request.controller.signal.aborted
     );
     if ([...agentSettingsDiscoveries.values()].some((request) => request.requestIds.has(command.requestId))) {
-      if (socket.readyState === WebSocket3.OPEN) {
+      if (socket.readyState === WebSocket4.OPEN) {
         send(socket, {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
@@ -98177,7 +98407,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
       return;
     }
     if (existing !== void 0) {
-      if (socket.readyState === WebSocket3.OPEN) {
+      if (socket.readyState === WebSocket4.OPEN) {
         send(socket, {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
@@ -98188,7 +98418,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
       return;
     }
     if (agentSettingsDiscoveries.size >= 4) {
-      if (socket.readyState === WebSocket3.OPEN) {
+      if (socket.readyState === WebSocket4.OPEN) {
         send(socket, {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
@@ -98226,7 +98456,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
           );
         }
         for (const requestId of requestIds) {
-          if (socket.readyState === WebSocket3.OPEN) {
+          if (socket.readyState === WebSocket4.OPEN) {
             send(socket, { ...result.event, requestId });
           }
         }
@@ -98240,7 +98470,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 `
           );
         }
-        if (socket.readyState === WebSocket3.OPEN) {
+        if (socket.readyState === WebSocket4.OPEN) {
           for (const requestId of requestIds) {
             send(socket, {
               code: operationErrorCode(failure2),
@@ -98410,7 +98640,7 @@ var init_session_files = __esm({
 });
 
 // src/runtime/command/registry/file-read/index.ts
-import { WebSocket as WebSocket4 } from "undici";
+import { WebSocket as WebSocket5 } from "undici";
 var fileReadCommand;
 var init_file_read = __esm({
   "src/runtime/command/registry/file-read/index.ts"() {
@@ -98431,7 +98661,7 @@ var init_file_read = __esm({
           sessions.findSessions([message.sessionId])[0]?.cwd ?? null,
           externalContent
         ).catch((error62) => {
-          if (socket.readyState !== WebSocket4.OPEN || signal.aborted) {
+          if (socket.readyState !== WebSocket5.OPEN || signal.aborted) {
             return;
           }
           send(socket, {
@@ -98804,7 +99034,7 @@ var init_interactions2 = __esm({
 });
 
 // src/runtime/command/native-session-requests.ts
-import { WebSocket as WebSocket5 } from "undici";
+import { WebSocket as WebSocket6 } from "undici";
 function createNativeSessionRequestHandler(dependencies) {
   const { diagnostics, nativeSessions, signal, socket, timer } = dependencies;
   const pending = /* @__PURE__ */ new Map();
@@ -98856,7 +99086,7 @@ function createNativeSessionRequestHandler(dependencies) {
         }
         operationSignal.throwIfAborted();
         const result = await nativeSessions.execute(command, operationSignal);
-        if (socket.readyState === WebSocket5.OPEN) {
+        if (socket.readyState === WebSocket6.OPEN) {
           send(socket, result);
         }
       } catch (error62) {
@@ -100041,6 +100271,7 @@ function createCommandRegistry(context) {
     sessionHistoryPageLoadCommand,
     previewHistoryPageLoadCommand,
     ...createNativeSessionCommands(context),
+    ...createAgentCatalogCommands(context),
     ...createAgentSettingsCommands(context),
     fileReadCommand,
     sessionCancelCommand,
@@ -100072,6 +100303,7 @@ function createCommandRegistry(context) {
 var init_registry2 = __esm({
   "src/runtime/command/registry/index.ts"() {
     "use strict";
+    init_agent_catalog();
     init_agent_settings();
     init_file_read();
     init_history2();
@@ -100119,14 +100351,14 @@ var init_runtime_revocation = __esm({
 });
 
 // src/runtime/relay/connect.ts
-import { WebSocket as WebSocket6 } from "undici";
+import { WebSocket as WebSocket7 } from "undici";
 function connectRelay(url2, signal) {
   signal.throwIfAborted();
   return new Promise((resolve20, reject2) => {
     const endpoint = new URL(url2);
     const headers = relayAuthorization(endpoint);
     endpoint.searchParams.delete("token");
-    const socket = new WebSocket6(endpoint, {
+    const socket = new WebSocket7(endpoint, {
       dispatcher: environmentProxyDispatcher,
       headers
     });
@@ -100331,7 +100563,7 @@ var init_liveness2 = __esm({
 });
 
 // src/runtime/relay/run-relay-connection.ts
-import { WebSocket as WebSocket7 } from "undici";
+import { WebSocket as WebSocket8 } from "undici";
 function closeRelaySocket(socket, code, reason) {
   try {
     socket.close(code, reason);
@@ -100362,7 +100594,7 @@ function readCommandCorrelation(encoded) {
   };
 }
 function rejectUnsupportedCommand(socket, correlation, rejection) {
-  if (socket.readyState !== WebSocket7.OPEN) {
+  if (socket.readyState !== WebSocket8.OPEN) {
     return;
   }
   send(socket, {
@@ -100410,7 +100642,7 @@ async function runRelayConnection({
     timer
   });
   void reportUpgradeAvailability((result) => {
-    if (socket.readyState === WebSocket7.OPEN) {
+    if (socket.readyState === WebSocket8.OPEN) {
       send(socket, result);
     }
   }, signal).catch((cause) => {
@@ -100461,14 +100693,14 @@ async function runRelayConnection({
       };
       const connectionLiveness = new RelayConnectionLiveness(timer, {
         send: (message) => {
-          if (socket.readyState !== WebSocket7.OPEN) {
+          if (socket.readyState !== WebSocket8.OPEN) {
             return false;
           }
           try {
             send(socket, message);
             return true;
           } catch (error62) {
-            if (socket.readyState !== WebSocket7.OPEN) {
+            if (socket.readyState !== WebSocket8.OPEN) {
               return false;
             }
             throw error62;
@@ -100585,7 +100817,7 @@ var init_run_relay_connection = __esm({
 });
 
 // src/runtime/relay/session-event-publisher.ts
-import { WebSocket as WebSocket8 } from "undici";
+import { WebSocket as WebSocket9 } from "undici";
 var MAX_BUFFERED_BYTES, MAX_PENDING_BYTES2, MAX_EVENT_BATCH_BYTES, MAX_FRAME_BYTES, LOCAL_BACKPRESSURE_CLOSE_CODE, EMPTY_ENVELOPE_BYTES, SESSION_EVENT_BATCH_WINDOW_MILLISECONDS, RuntimeSessionEventPublisher;
 var init_session_event_publisher = __esm({
   "src/runtime/relay/session-event-publisher.ts"() {
@@ -100640,7 +100872,7 @@ var init_session_event_publisher = __esm({
       publishClosed = (event) => this.#send(event);
       #send = (message) => {
         const connection = this.#connection;
-        if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket8.OPEN) {
+        if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket9.OPEN) {
           return;
         }
         const socket = connection.socket;
@@ -100691,7 +100923,7 @@ var init_session_event_publisher = __esm({
         batch.bytes += bytes;
         this.#pendingBytes += additionalBytes;
         const connection = this.#connection;
-        if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket8.OPEN) {
+        if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket9.OPEN) {
           return;
         }
         const socket = connection.socket;
@@ -100711,7 +100943,7 @@ var init_session_event_publisher = __esm({
       flushEvents = (socket) => {
         this.cancelFlush();
         const connection = this.#connection;
-        if (connection.kind !== "connected" || connection.socket !== socket || socket.readyState !== WebSocket8.OPEN) {
+        if (connection.kind !== "connected" || connection.socket !== socket || socket.readyState !== WebSocket9.OPEN) {
           return;
         }
         let attempted = 0;