chatroom-cli 1.98.0 → 1.98.1

package/dist/index.js

@@ -7661,7 +7661,7 @@ var init_simple_client_node = __esm(() => {
         NOOP
       } = require_constants();
       var {
-        EventTarget: { addEventListener, removeEventListener }
+        EventTarget: { addEventListener: addEventListener2, removeEventListener: removeEventListener2 }
       } = require_event_target();
       var { format, parse } = require_extension();
       var { toBuffer } = require_buffer_util();
@@ -7990,8 +7990,8 @@ var init_simple_client_node = __esm(() => {
           }
         });
       });
-      WebSocket2.prototype.addEventListener = addEventListener;
-      WebSocket2.prototype.removeEventListener = removeEventListener;
+      WebSocket2.prototype.addEventListener = addEventListener2;
+      WebSocket2.prototype.removeEventListener = removeEventListener2;
       module.exports = WebSocket2;
       function initAsClient(websocket, address, protocols, options) {
         const opts = {
@@ -8153,9 +8153,9 @@ var init_simple_client_node = __esm(() => {
           emitErrorAndClose(websocket, err);
         });
         req.on("response", (res) => {
-          const location = res.headers.location;
+          const location2 = res.headers.location;
           const statusCode = res.statusCode;
-          if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+          if (location2 && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
             if (++websocket._redirects > opts.maxRedirects) {
               abortHandshake(websocket, req, "Maximum redirects exceeded");
               return;
@@ -8163,9 +8163,9 @@ var init_simple_client_node = __esm(() => {
             req.abort();
             let addr;
             try {
-              addr = new URL2(location, address);
+              addr = new URL2(location2, address);
             } catch (e) {
-              const err = new SyntaxError(`Invalid URL: ${location}`);
+              const err = new SyntaxError(`Invalid URL: ${location2}`);
               emitErrorAndClose(websocket, err);
               return;
             }
@@ -12615,9 +12615,9 @@ ${prefix}}`;
         if (typeof stack2 === "string") {
           const locationMatchAll = stack2.matchAll(locationRegex);
           let match4 = false;
-          for (const [, location] of locationMatchAll) {
+          for (const [, location2] of locationMatchAll) {
             match4 = true;
-            out.push(`    at ${current.name} (${location})`);
+            out.push(`    at ${current.name} (${location2})`);
           }
           if (!match4) {
             out.push(`    at ${current.name} (${stack2.replace(/^at /, "")})`);
@@ -52959,13 +52959,13 @@ var require_lib3 = __commonJS((exports, module) => {
         clearTimeout(reqTimeout);
         const headers = createHeadersLenient(res.headers);
         if (fetch2.isRedirect(res.statusCode)) {
-          const location = headers.get("Location");
+          const location2 = headers.get("Location");
           let locationURL = null;
           try {
-            locationURL = location === null ? null : new URL$1(location, request2.url).toString();
+            locationURL = location2 === null ? null : new URL$1(location2, request2.url).toString();
           } catch (err) {
             if (request2.redirect !== "manual") {
-              reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
+              reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location2}`, "invalid-redirect"));
               finalize();
               return;
             }
@@ -67066,8 +67066,8 @@ var require_follow_redirects = __commonJS((exports, module) => {
         statusCode
       });
     }
-    var location = response.headers.location;
-    if (!location || this._options.followRedirects === false || statusCode < 300 || statusCode >= 400) {
+    var location2 = response.headers.location;
+    if (!location2 || this._options.followRedirects === false || statusCode < 300 || statusCode >= 400) {
       response.responseUrl = this._currentUrl;
       response.redirects = this._redirects;
       this.emit("response", response);
@@ -67095,8 +67095,8 @@ var require_follow_redirects = __commonJS((exports, module) => {
     var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
     var currentUrlParts = parseUrl2(this._currentUrl);
     var currentHost = currentHostHeader || currentUrlParts.host;
-    var currentUrl = /^\w+:/.test(location) ? this._currentUrl : url2.format(Object.assign(currentUrlParts, { host: currentHost }));
-    var redirectUrl = resolveUrl(location, currentUrl);
+    var currentUrl = /^\w+:/.test(location2) ? this._currentUrl : url2.format(Object.assign(currentUrlParts, { host: currentHost }));
+    var redirectUrl = resolveUrl(location2, currentUrl);
     debug("redirecting to", redirectUrl.href);
     this._isRedirect = true;
     spreadUrlObject(redirectUrl, this._options);
@@ -67687,10 +67687,10 @@ var init_callbackify = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/axios@1.19.0/node_modules/axios/lib/helpers/shouldBypassProxy.js
-function shouldBypassProxy(location) {
+function shouldBypassProxy(location2) {
   let parsed;
   try {
-    parsed = new URL(location);
+    parsed = new URL(location2);
   } catch (_err) {
     return false;
   }
@@ -68195,13 +68195,13 @@ function isSameOriginRedirect(redirectOptions, requestDetails) {
     return false;
   }
 }
-function setProxy(options, configProxy, location, isRedirect, configHttpsAgent, configHttpAgent) {
+function setProxy(options, configProxy, location2, isRedirect, configHttpsAgent, configHttpAgent) {
   let proxy = configProxy;
   const proxyEnvAgent = getProxyEnvAgent(options, configHttpAgent, configHttpsAgent);
   if (!proxy && proxy !== false && !isNodeEnvProxyEnabled(proxyEnvAgent)) {
-    const proxyUrl = getProxyForUrl(location);
+    const proxyUrl = getProxyForUrl(location2);
     if (proxyUrl) {
-      if (!shouldBypassProxy(location)) {
+      if (!shouldBypassProxy(location2)) {
         proxy = new URL(proxyUrl);
       }
     }
@@ -68279,7 +68279,7 @@ function setProxy(options, configProxy, location, isRedirect, configHttpsAgent,
       options.hostname = proxyHost;
       options.host = proxyHost;
       options.port = readProxyField("port");
-      options.path = location;
+      options.path = location2;
       const proxyProtocol = readProxyField("protocol");
       if (proxyProtocol) {
         options.protocol = proxyProtocol.includes(":") ? proxyProtocol : `${proxyProtocol}:`;
@@ -101360,7 +101360,7 @@ class AgentProcessManager {
       signal: undefined,
       agentHarness: undefined
     };
-    this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs1).catch((err) => {
+    this.deps.logEvent({ type: "agent.exited", timestamp: Date.now(), ...exitArgs1 }).catch((err) => {
       console.log(`   ⚠️  Failed to record agent exit (idle cleanup): ${err.message}`);
       this.queueExitRetry({ role: opts.role, args: exitArgs1 });
     });
@@ -101540,7 +101540,7 @@ class AgentProcessManager {
       signal: opts.signal ?? undefined,
       agentHarness: ctx.harness
     };
-    this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs2).catch((err) => {
+    this.deps.logEvent({ type: "agent.exited", timestamp: Date.now(), ...exitArgs2 }).catch((err) => {
       console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
       this.queueExitRetry({ role: opts.role, args: exitArgs2 });
     });
@@ -101904,7 +101904,7 @@ class AgentProcessManager {
     }
   }
   recordAgentExitedOrQueueRetry(role, exitArgs, failureLog) {
-    this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs).catch((err) => {
+    this.deps.logEvent({ type: "agent.exited", timestamp: Date.now(), ...exitArgs }).catch((err) => {
       console.log(`   ⚠️  ${failureLog}: ${err.message}`);
       this.queueExitRetry({ role, args: exitArgs });
     });
@@ -101932,7 +101932,7 @@ class AgentProcessManager {
     for (let i2 = this.exitRetryQueue.length - 1;i2 >= 0; i2--) {
       const item = this.exitRetryQueue[i2];
       try {
-        await this.deps.backend.mutation(api.machines.recordAgentExited, item.args);
+        await this.deps.logEvent({ type: "agent.exited", timestamp: Date.now(), ...item.args });
         this.exitRetryQueue.splice(i2, 1);
         console.log(`[AgentProcessManager] ✅ Successfully retried agent exit event for ${item.role}`);
       } catch {}
@@ -102514,7 +102514,7 @@ class AgentProcessManager {
       signal: undefined,
       agentHarness: slot.harness
     };
-    this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs3).catch((err) => {
+    this.deps.logEvent({ type: "agent.exited", timestamp: Date.now(), ...exitArgs3 }).catch((err) => {
       console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
       this.queueExitRetry({ role: opts.role, args: exitArgs3 });
     });
@@ -102631,6 +102631,9 @@ function assembleDaemonSessionInit(args2) {
   deps.backend.mutation = (endpoint, args3) => client4.mutation(endpoint, args3);
   deps.backend.query = (endpoint, args3) => client4.query(endpoint, args3);
   deps.agentProcessManager = new AgentProcessManager({
+    logEvent: activeLogEvent ?? (async () => {
+      return;
+    }),
     logSink: activeLogSink,
     agentServices,
     backend: deps.backend,
@@ -102678,6 +102681,7 @@ function getActiveLogSink() {
 }
 async function initDaemon(options = {}) {
   activeLogSink = options.logSink;
+  activeLogEvent = options.logEvent;
   return exports_Effect.runPromise(initDaemonEffect);
 }
 var discoverModelsEffect = (agentServices) => exports_Effect.gen(function* () {
@@ -102811,7 +102815,7 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
   const cachedModels = yield* fetchCachedMachineModelsEffect(client4, typedSessionId, machineId);
   yield* connectDaemonEffect(client4, typedSessionId, machineId);
   return { typedSessionId, config: config4, machineId, agentServices, cachedModels };
-}), activeLogSink, connectDaemonEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
+}), activeLogSink, activeLogEvent, connectDaemonEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
   try: () => client4.mutation(api.machines.updateDaemonStatus, {
     sessionId: asConvexSessionId(sessionId),
     machineId,
@@ -117410,7 +117414,7 @@ var init_resolve_logs_db_path = __esm(() => {
 });
 
 // src/infrastructure/log-server/log-schema.ts
-var SCHEMA_VERSION = 1, MIGRATIONS;
+var SCHEMA_VERSION = 2, MIGRATIONS;
 var init_log_schema = __esm(() => {
   MIGRATIONS = [
     `CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
@@ -117423,7 +117427,15 @@ var init_log_schema = __esm(() => {
     message TEXT NOT NULL,
     metadata_json TEXT
   )`,
-    `CREATE INDEX IF NOT EXISTS idx_log_entries_source_id ON log_entries(source, id)`
+    `CREATE INDEX IF NOT EXISTS idx_log_entries_source_id ON log_entries(source, id)`,
+    `CREATE TABLE IF NOT EXISTS event_stream_entries (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp INTEGER NOT NULL,
+    type TEXT NOT NULL,
+    payload_json TEXT NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_event_stream_entries_timestamp_id ON event_stream_entries(timestamp, id)`,
+    `CREATE INDEX IF NOT EXISTS idx_event_stream_entries_chatroom_id ON event_stream_entries(json_extract(payload_json, '$.chatroomId'), id)`
   ];
 });
 
@@ -117461,6 +117473,35 @@ function appendBatch(db, entries2) {
     throw error51;
   }
 }
+function appendChatroomEvent(db, event) {
+  db.prepare("INSERT INTO event_stream_entries(timestamp,type,payload_json) VALUES(?,?,?)").run(event.timestamp, event.type, JSON.stringify(event));
+}
+function queryEventStream(db, input) {
+  const filters = [
+    "AND json_extract(payload_json, '$.chatroomId') = ?",
+    input.afterId !== undefined ? "AND id > ?" : "",
+    input.beforeId !== undefined ? "AND id < ?" : "",
+    input.type ? "AND type = ?" : "",
+    input.fromTimestamp !== undefined ? "AND timestamp >= ?" : "",
+    input.toTimestamp !== undefined ? "AND timestamp <= ?" : ""
+  ].join(" ");
+  const values3 = [
+    input.chatroomId,
+    ...input.afterId !== undefined ? [input.afterId] : [],
+    ...input.beforeId !== undefined ? [input.beforeId] : [],
+    ...input.type ? [input.type] : [],
+    ...input.fromTimestamp !== undefined ? [input.fromTimestamp] : [],
+    ...input.toTimestamp !== undefined ? [input.toTimestamp] : [],
+    clamp4(input.limit)
+  ];
+  const rows2 = db.prepare(`SELECT * FROM event_stream_entries WHERE 1=1 ${filters} ORDER BY id DESC LIMIT ?`).all(...values3);
+  return rows2.reverse().map((row) => ({
+    id: Number(row.id),
+    timestamp: Number(row.timestamp),
+    type: row.type,
+    payload: JSON.parse(row.payload_json)
+  }));
+}
 function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
   const filters = [
     source ? "AND source = ?" : "",
@@ -117704,6 +117745,12 @@ function createLogRepository(db) {
     },
     listDimensions(limit = 100) {
       return listLogDimensions(db, limit);
+    },
+    writeChatroomEvent(event) {
+      appendChatroomEvent(db, event);
+    },
+    queryEventStream(input) {
+      return queryEventStream(db, input);
     }
   };
 }
@@ -119506,7 +119553,7 @@ var require_webtransport = __commonJS((exports) => {
   var engine_io_parser_1 = require_cjs();
   var debug2 = (0, debug_1.default)("engine:webtransport");
 
-  class WebTransport extends transport_1.Transport {
+  class WebTransport2 extends transport_1.Transport {
     constructor(session2, stream4, reader) {
       super({ _query: { EIO: "4" } });
       this.session = session2;
@@ -119556,7 +119603,7 @@ var require_webtransport = __commonJS((exports) => {
       fn2 && fn2();
     }
   }
-  exports.WebTransport = WebTransport;
+  exports.WebTransport = WebTransport2;
 });
 
 // ../../node_modules/.pnpm/engine.io@6.6.9/node_modules/engine.io/build/transports/index.js
@@ -121764,7 +121811,7 @@ var require_websocket3 = __commonJS((exports, module) => {
     NOOP
   } = require_constants3();
   var {
-    EventTarget: { addEventListener, removeEventListener }
+    EventTarget: { addEventListener: addEventListener2, removeEventListener: removeEventListener2 }
   } = require_event_target2();
   var { format: format5, parse: parse8 } = require_extension2();
   var { toBuffer } = require_buffer_util2();
@@ -122094,8 +122141,8 @@ var require_websocket3 = __commonJS((exports, module) => {
       }
     });
   });
-  WebSocket2.prototype.addEventListener = addEventListener;
-  WebSocket2.prototype.removeEventListener = removeEventListener;
+  WebSocket2.prototype.addEventListener = addEventListener2;
+  WebSocket2.prototype.removeEventListener = removeEventListener2;
   module.exports = WebSocket2;
   function initAsClient(websocket, address, protocols, options) {
     const opts = {
@@ -122257,9 +122304,9 @@ var require_websocket3 = __commonJS((exports, module) => {
       emitErrorAndClose(websocket, err);
     });
     req.on("response", (res) => {
-      const location = res.headers.location;
+      const location2 = res.headers.location;
       const statusCode = res.statusCode;
-      if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+      if (location2 && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
         if (++websocket._redirects > opts.maxRedirects) {
           abortHandshake(websocket, req, "Maximum redirects exceeded");
           return;
@@ -122267,9 +122314,9 @@ var require_websocket3 = __commonJS((exports, module) => {
         req.abort();
         let addr;
         try {
-          addr = new URL2(location, address);
+          addr = new URL2(location2, address);
         } catch (e) {
-          const err = new SyntaxError(`Invalid URL: ${location}`);
+          const err = new SyntaxError(`Invalid URL: ${location2}`);
           emitErrorAndClose(websocket, err);
           return;
         }
@@ -128171,7 +128218,7 @@ var init_normalize_error = __esm(() => {
 });
 
 // src/daemon/infrastructure/socket/schemas.ts
-var harnessHistoryInputSchema, logHistoryInputSchema, logSourcesInputSchema;
+var harnessHistoryInputSchema, logHistoryInputSchema, logSourcesInputSchema, eventStreamHistoryInputSchema, chatroomEventIngestInputSchema;
 var init_schemas3 = __esm(() => {
   init_zod();
   harnessHistoryInputSchema = exports_external.object({
@@ -128194,8 +128241,29 @@ var init_schemas3 = __esm(() => {
   logSourcesInputSchema = exports_external.object({
     limit: exports_external.number().int().positive().max(1000).optional()
   });
+  eventStreamHistoryInputSchema = exports_external.object({
+    chatroomId: exports_external.string().min(1),
+    afterId: exports_external.number().int().nonnegative().optional(),
+    beforeId: exports_external.number().int().positive().optional(),
+    type: exports_external.string().optional(),
+    fromTimestamp: exports_external.number().int().nonnegative().optional(),
+    toTimestamp: exports_external.number().int().nonnegative().optional(),
+    limit: exports_external.number().int().positive().max(1000).optional()
+  });
+  chatroomEventIngestInputSchema = exports_external.object({
+    type: exports_external.string().min(1),
+    timestamp: exports_external.number(),
+    chatroomId: exports_external.string().min(1).optional()
+  }).passthrough();
 });
 
+// src/daemon/domain/usecase/event-stream-history.ts
+function createEventStreamHistoryUseCase(deps) {
+  return (input) => ({
+    entries: deps.reader.queryEventStream(input)
+  });
+}
+
 // src/daemon/domain/usecase/get-local-web-health.ts
 function getLocalWebHealth(port) {
   return { status: "ok", service: "v2-local-web", port };
@@ -128223,6 +128291,37 @@ function listLogSources(reader, limit = 100) {
   return { sources: reader.listSources(limit) };
 }
 
+// src/daemon/domain/usecase/log-dimensions.ts
+function createLogDimensionsUseCase(deps) {
+  return (limit) => listLogDimensions2(deps.reader, limit);
+}
+var init_log_dimensions = () => {};
+
+// src/daemon/domain/usecase/log-event-ingestion.ts
+function createLogEventIngestionUseCase(deps) {
+  return (event) => {
+    deps.writer.writeChatroomEvent(event);
+    return { accepted: true };
+  };
+}
+
+// src/daemon/domain/usecase/log-history.ts
+function createLogHistoryUseCase(deps) {
+  return (input) => listLogHistory(deps.reader, input);
+}
+var init_log_history = () => {};
+
+// src/daemon/domain/usecase/log-sources.ts
+function createLogSourcesUseCase(deps) {
+  return (limit) => listLogSources(deps.reader, limit);
+}
+var init_log_sources = () => {};
+
+// src/daemon/domain/usecase/subscribe-log-stream.ts
+function createSubscribeLogStreamUseCase(deps) {
+  return (onEvent) => deps.hub.subscribe(onEvent);
+}
+
 // src/daemon/infrastructure/socket/register-handlers.ts
 function callAck(ack, response) {
   if (typeof ack === "function") {
@@ -128237,6 +128336,12 @@ function extractAck(args2) {
   return { payload: args2[0], ack: undefined };
 }
 function registerSocketHandlers(io2, deps) {
+  const logHistory = deps.logRepo ? createLogHistoryUseCase({ reader: deps.logRepo }) : undefined;
+  const eventStreamHistory = deps.logRepo ? createEventStreamHistoryUseCase({ reader: deps.logRepo }) : undefined;
+  const logEventIngestion = deps.logRepo ? createLogEventIngestionUseCase({ writer: deps.logRepo }) : undefined;
+  const logSources = deps.logRepo ? createLogSourcesUseCase({ reader: deps.logRepo }) : undefined;
+  const logDimensions = deps.logRepo ? createLogDimensionsUseCase({ reader: deps.logRepo }) : undefined;
+  const subscribeLogStream = deps.logStreamHub ? createSubscribeLogStreamUseCase({ hub: deps.logStreamHub }) : undefined;
   io2.on("connection", (socket) => {
     const streamUnsubs = [];
     socket.on("health.get", (...args2) => {
@@ -128274,23 +128379,45 @@ function registerSocketHandlers(io2, deps) {
     socket.on("logs.history", (...args2) => {
       const { payload, ack } = extractAck(args2);
       try {
-        if (!deps.logRepo)
-          throw new Error("log repository not configured");
+        if (!logHistory)
+          throw new Error("log history use case not configured");
         callAck(ack, {
           ok: true,
-          data: listLogHistory(deps.logRepo, logHistoryInputSchema.parse(payload ?? {}))
+          data: logHistory(logHistoryInputSchema.parse(payload ?? {}))
         });
       } catch (err) {
         callAck(ack, { ok: false, error: normalizeError(err) });
       }
     });
+    socket.on("eventStream.ingest", (...args2) => {
+      const { payload, ack } = extractAck(args2);
+      try {
+        if (!logEventIngestion)
+          throw new Error("log event ingestion use case not configured");
+        const event = chatroomEventIngestInputSchema.parse(payload);
+        callAck(ack, { ok: true, data: logEventIngestion(event) });
+      } catch (err) {
+        callAck(ack, { ok: false, error: normalizeError(err) });
+      }
+    });
+    socket.on("eventStream.history", (...args2) => {
+      const { payload, ack } = extractAck(args2);
+      try {
+        if (!eventStreamHistory)
+          throw new Error("event stream use case not configured");
+        const input = eventStreamHistoryInputSchema.parse(payload ?? {});
+        callAck(ack, { ok: true, data: eventStreamHistory(input) });
+      } catch (err) {
+        callAck(ack, { ok: false, error: normalizeError(err) });
+      }
+    });
     socket.on("logs.sources", (...args2) => {
       const { payload, ack } = extractAck(args2);
       try {
-        if (!deps.logRepo)
-          throw new Error("log repository not configured");
+        if (!logSources)
+          throw new Error("log sources use case not configured");
         const parsed = logSourcesInputSchema.parse(payload ?? {});
-        callAck(ack, { ok: true, data: listLogSources(deps.logRepo, parsed.limit) });
+        callAck(ack, { ok: true, data: logSources(parsed.limit) });
       } catch (err) {
         callAck(ack, { ok: false, error: normalizeError(err) });
       }
@@ -128298,10 +128425,10 @@ function registerSocketHandlers(io2, deps) {
     socket.on("logs.dimensions", (...args2) => {
       const { payload, ack } = extractAck(args2);
       try {
-        if (!deps.logRepo)
-          throw new Error("log repository not configured");
+        if (!logDimensions)
+          throw new Error("log dimensions use case not configured");
         const parsed = logSourcesInputSchema.parse(payload ?? {});
-        callAck(ack, { ok: true, data: listLogDimensions2(deps.logRepo, parsed.limit) });
+        callAck(ack, { ok: true, data: logDimensions(parsed.limit) });
       } catch (err) {
         callAck(ack, { ok: false, error: normalizeError(err) });
       }
@@ -128330,9 +128457,9 @@ function registerSocketHandlers(io2, deps) {
     socket.on("logs.stream.subscribe", (...args2) => {
       const { ack } = extractAck(args2);
       try {
-        if (!deps.logStreamHub)
-          throw new Error("log stream hub not configured");
-        const unsub = deps.logStreamHub.subscribe((event) => socket.emit("logs.stream", event));
+        if (!subscribeLogStream)
+          throw new Error("log stream use case not configured");
+        const unsub = subscribeLogStream((event) => socket.emit("logs.stream", event));
         streamUnsubs.push(unsub);
         callAck(ack, { ok: true, data: { subscribed: true } });
       } catch (err) {
@@ -128349,6 +128476,9 @@ var init_register_handlers = __esm(() => {
   init_normalize_error();
   init_schemas3();
   init_api3();
+  init_log_dimensions();
+  init_log_history();
+  init_log_sources();
 });
 
 // src/daemon/local-web/server/create-local-web-server.ts
@@ -128424,15 +128554,3293 @@ function createLogStreamHub() {
   } };
 }
 
-// src/daemon/entry/start-daemon.ts
-async function startDaemon() {
-  const logStreamHub = createLogStreamHub();
-  const logServer = createLogServer(resolveLogsDbPath(), {
-    onWrite: (entry) => logStreamHub.publish(entry)
+// ../../node_modules/.pnpm/xmlhttprequest-ssl@2.1.2/node_modules/xmlhttprequest-ssl/lib/XMLHttpRequest.js
+var require_XMLHttpRequest = __commonJS((exports, module) => {
+  var fs12 = __require("fs");
+  var Url = __require("url");
+  var spawn7 = __require("child_process").spawn;
+  module.exports = XMLHttpRequest2;
+  XMLHttpRequest2.XMLHttpRequest = XMLHttpRequest2;
+  function XMLHttpRequest2(opts) {
+    opts = opts || {};
+    var self2 = this;
+    var http3 = __require("http");
+    var https2 = __require("https");
+    var request2;
+    var response;
+    var settings = {};
+    var disableHeaderCheck = false;
+    var defaultHeaders2 = {
+      "User-Agent": "node-XMLHttpRequest",
+      Accept: "*/*"
+    };
+    var headers = Object.assign({}, defaultHeaders2);
+    var forbiddenRequestHeaders = [
+      "accept-charset",
+      "accept-encoding",
+      "access-control-request-headers",
+      "access-control-request-method",
+      "connection",
+      "content-length",
+      "content-transfer-encoding",
+      "cookie",
+      "cookie2",
+      "date",
+      "expect",
+      "host",
+      "keep-alive",
+      "origin",
+      "referer",
+      "te",
+      "trailer",
+      "transfer-encoding",
+      "upgrade",
+      "via"
+    ];
+    var forbiddenRequestMethods = [
+      "TRACE",
+      "TRACK",
+      "CONNECT"
+    ];
+    var sendFlag = false;
+    var errorFlag = false;
+    var abortedFlag = false;
+    var listeners = {};
+    this.UNSENT = 0;
+    this.OPENED = 1;
+    this.HEADERS_RECEIVED = 2;
+    this.LOADING = 3;
+    this.DONE = 4;
+    this.readyState = this.UNSENT;
+    this.onreadystatechange = null;
+    this.responseText = "";
+    this.responseXML = "";
+    this.response = Buffer.alloc(0);
+    this.status = null;
+    this.statusText = null;
+    var isAllowedHttpHeader = function(header) {
+      return disableHeaderCheck || header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1;
+    };
+    var isAllowedHttpMethod = function(method) {
+      return method && forbiddenRequestMethods.indexOf(method) === -1;
+    };
+    this.open = function(method, url3, async2, user, password) {
+      this.abort();
+      errorFlag = false;
+      abortedFlag = false;
+      if (!isAllowedHttpMethod(method)) {
+        throw new Error("SecurityError: Request method not allowed");
+      }
+      settings = {
+        method,
+        url: url3.toString(),
+        async: typeof async2 !== "boolean" ? true : async2,
+        user: user || null,
+        password: password || null
+      };
+      setState(this.OPENED);
+    };
+    this.setDisableHeaderCheck = function(state) {
+      disableHeaderCheck = state;
+    };
+    this.setRequestHeader = function(header, value) {
+      if (this.readyState != this.OPENED) {
+        throw new Error("INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN");
+      }
+      if (!isAllowedHttpHeader(header)) {
+        console.warn('Refused to set unsafe header "' + header + '"');
+        return false;
+      }
+      if (sendFlag) {
+        throw new Error("INVALID_STATE_ERR: send flag is true");
+      }
+      headers[header] = value;
+      return true;
+    };
+    this.getResponseHeader = function(header) {
+      if (typeof header === "string" && this.readyState > this.OPENED && response.headers[header.toLowerCase()] && !errorFlag) {
+        return response.headers[header.toLowerCase()];
+      }
+      return null;
+    };
+    this.getAllResponseHeaders = function() {
+      if (this.readyState < this.HEADERS_RECEIVED || errorFlag) {
+        return "";
+      }
+      var result = "";
+      for (var i2 in response.headers) {
+        if (i2 !== "set-cookie" && i2 !== "set-cookie2") {
+          result += i2 + ": " + response.headers[i2] + `\r
+`;
+        }
+      }
+      return result.substr(0, result.length - 2);
+    };
+    this.getRequestHeader = function(name) {
+      if (typeof name === "string" && headers[name]) {
+        return headers[name];
+      }
+      return "";
+    };
+    this.send = function(data) {
+      if (this.readyState != this.OPENED) {
+        throw new Error("INVALID_STATE_ERR: connection must be opened before send() is called");
+      }
+      if (sendFlag) {
+        throw new Error("INVALID_STATE_ERR: send has already been called");
+      }
+      var ssl = false, local = false;
+      var url3 = Url.parse(settings.url);
+      var host;
+      switch (url3.protocol) {
+        case "https:":
+          ssl = true;
+        case "http:":
+          host = url3.hostname;
+          break;
+        case "file:":
+          local = true;
+          break;
+        case undefined:
+        case "":
+          host = "localhost";
+          break;
+        default:
+          throw new Error("Protocol not supported.");
+      }
+      if (local) {
+        if (settings.method !== "GET") {
+          throw new Error("XMLHttpRequest: Only GET method is supported");
+        }
+        if (settings.async) {
+          fs12.readFile(unescape(url3.pathname), function(error51, data2) {
+            if (error51) {
+              self2.handleError(error51, error51.errno || -1);
+            } else {
+              self2.status = 200;
+              self2.responseText = data2.toString("utf8");
+              self2.response = data2;
+              setState(self2.DONE);
+            }
+          });
+        } else {
+          try {
+            this.response = fs12.readFileSync(unescape(url3.pathname));
+            this.responseText = this.response.toString("utf8");
+            this.status = 200;
+            setState(self2.DONE);
+          } catch (e) {
+            this.handleError(e, e.errno || -1);
+          }
+        }
+        return;
+      }
+      var port = url3.port || (ssl ? 443 : 80);
+      var uri = url3.pathname + (url3.search ? url3.search : "");
+      headers["Host"] = host;
+      if (!(ssl && port === 443 || port === 80)) {
+        headers["Host"] += ":" + url3.port;
+      }
+      if (settings.user) {
+        if (typeof settings.password == "undefined") {
+          settings.password = "";
+        }
+        var authBuf = new Buffer(settings.user + ":" + settings.password);
+        headers["Authorization"] = "Basic " + authBuf.toString("base64");
+      }
+      if (settings.method === "GET" || settings.method === "HEAD") {
+        data = null;
+      } else if (data) {
+        headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
+        var headersKeys = Object.keys(headers);
+        if (!headersKeys.some(function(h) {
+          return h.toLowerCase() === "content-type";
+        })) {
+          headers["Content-Type"] = "text/plain;charset=UTF-8";
+        }
+      } else if (settings.method === "POST") {
+        headers["Content-Length"] = 0;
+      }
+      var agent = opts.agent || false;
+      var options = {
+        host,
+        port,
+        path: uri,
+        method: settings.method,
+        headers,
+        agent
+      };
+      if (ssl) {
+        options.pfx = opts.pfx;
+        options.key = opts.key;
+        options.passphrase = opts.passphrase;
+        options.cert = opts.cert;
+        options.ca = opts.ca;
+        options.ciphers = opts.ciphers;
+        options.rejectUnauthorized = opts.rejectUnauthorized === false ? false : true;
+      }
+      errorFlag = false;
+      if (settings.async) {
+        var doRequest = ssl ? https2.request : http3.request;
+        sendFlag = true;
+        self2.dispatchEvent("readystatechange");
+        var responseHandler = function(resp2) {
+          response = resp2;
+          if (response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
+            settings.url = response.headers.location;
+            var url4 = Url.parse(settings.url);
+            host = url4.hostname;
+            var newOptions = {
+              hostname: url4.hostname,
+              port: url4.port,
+              path: url4.path,
+              method: response.statusCode === 303 ? "GET" : settings.method,
+              headers
+            };
+            if (ssl) {
+              newOptions.pfx = opts.pfx;
+              newOptions.key = opts.key;
+              newOptions.passphrase = opts.passphrase;
+              newOptions.cert = opts.cert;
+              newOptions.ca = opts.ca;
+              newOptions.ciphers = opts.ciphers;
+              newOptions.rejectUnauthorized = opts.rejectUnauthorized === false ? false : true;
+            }
+            request2 = doRequest(newOptions, responseHandler).on("error", errorHandler);
+            request2.end();
+            return;
+          }
+          setState(self2.HEADERS_RECEIVED);
+          self2.status = response.statusCode;
+          response.on("data", function(chunk2) {
+            if (chunk2) {
+              var data2 = Buffer.from(chunk2);
+              self2.response = Buffer.concat([self2.response, data2]);
+            }
+            if (sendFlag) {
+              setState(self2.LOADING);
+            }
+          });
+          response.on("end", function() {
+            if (sendFlag) {
+              sendFlag = false;
+              setState(self2.DONE);
+              self2.responseText = self2.response.toString("utf8");
+            }
+          });
+          response.on("error", function(error51) {
+            self2.handleError(error51);
+          });
+        };
+        var errorHandler = function(error51) {
+          if (request2.reusedSocket && error51.code === "ECONNRESET")
+            return doRequest(options, responseHandler).on("error", errorHandler);
+          self2.handleError(error51);
+        };
+        request2 = doRequest(options, responseHandler).on("error", errorHandler);
+        if (opts.autoUnref) {
+          request2.on("socket", (socket) => {
+            socket.unref();
+          });
+        }
+        if (data) {
+          request2.write(data);
+        }
+        request2.end();
+        self2.dispatchEvent("loadstart");
+      } else {
+        var contentFile = ".node-xmlhttprequest-content-" + process.pid;
+        var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
+        fs12.writeFileSync(syncFile, "", "utf8");
+        var execString = "var http = require('http'), https = require('https'), fs = require('fs');" + "var doRequest = http" + (ssl ? "s" : "") + ".request;" + "var options = " + JSON.stringify(options) + ";" + "var responseText = '';" + "var responseData = Buffer.alloc(0);" + "var req = doRequest(options, function(response) {" + "response.on('data', function(chunk) {" + "  var data = Buffer.from(chunk);" + "  responseText += data.toString('utf8');" + "  responseData = Buffer.concat([responseData, data]);" + "});" + "response.on('end', function() {" + "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');" + "fs.unlinkSync('" + syncFile + "');" + "});" + "response.on('error', function(error) {" + "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');" + "fs.unlinkSync('" + syncFile + "');" + "});" + "}).on('error', function(error) {" + "fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');" + "fs.unlinkSync('" + syncFile + "');" + "});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
+        var syncProc = spawn7(process.argv[0], ["-e", execString]);
+        var statusText;
+        while (fs12.existsSync(syncFile)) {}
+        self2.responseText = fs12.readFileSync(contentFile, "utf8");
+        syncProc.stdin.end();
+        fs12.unlinkSync(contentFile);
+        if (self2.responseText.match(/^NODE-XMLHTTPREQUEST-ERROR:/)) {
+          var errorObj = JSON.parse(self2.responseText.replace(/^NODE-XMLHTTPREQUEST-ERROR:/, ""));
+          self2.handleError(errorObj, 503);
+        } else {
+          self2.status = self2.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:([0-9]*),.*/, "$1");
+          var resp = JSON.parse(self2.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:[0-9]*,(.*)/, "$1"));
+          response = {
+            statusCode: self2.status,
+            headers: resp.data.headers
+          };
+          self2.responseText = resp.data.text;
+          self2.response = Buffer.from(resp.data.data, "base64");
+          setState(self2.DONE, true);
+        }
+      }
+    };
+    this.handleError = function(error51, status3) {
+      this.status = status3 || 0;
+      this.statusText = error51;
+      this.responseText = error51.stack;
+      errorFlag = true;
+      setState(this.DONE);
+    };
+    this.abort = function() {
+      if (request2) {
+        request2.abort();
+        request2 = null;
+      }
+      headers = Object.assign({}, defaultHeaders2);
+      this.responseText = "";
+      this.responseXML = "";
+      this.response = Buffer.alloc(0);
+      errorFlag = abortedFlag = true;
+      if (this.readyState !== this.UNSENT && (this.readyState !== this.OPENED || sendFlag) && this.readyState !== this.DONE) {
+        sendFlag = false;
+        setState(this.DONE);
+      }
+      this.readyState = this.UNSENT;
+    };
+    this.addEventListener = function(event, callback) {
+      if (!(event in listeners)) {
+        listeners[event] = [];
+      }
+      listeners[event].push(callback);
+    };
+    this.removeEventListener = function(event, callback) {
+      if (event in listeners) {
+        listeners[event] = listeners[event].filter(function(ev) {
+          return ev !== callback;
+        });
+      }
+    };
+    this.dispatchEvent = function(event) {
+      if (typeof self2["on" + event] === "function") {
+        if (this.readyState === this.DONE && settings.async)
+          setTimeout(function() {
+            self2["on" + event]();
+          }, 0);
+        else
+          self2["on" + event]();
+      }
+      if (event in listeners) {
+        for (let i2 = 0, len2 = listeners[event].length;i2 < len2; i2++) {
+          if (this.readyState === this.DONE)
+            setTimeout(function() {
+              listeners[event][i2].call(self2);
+            }, 0);
+          else
+            listeners[event][i2].call(self2);
+        }
+      }
+    };
+    var setState = function(state) {
+      if (self2.readyState === state || self2.readyState === self2.UNSENT && abortedFlag)
+        return;
+      self2.readyState = state;
+      if (settings.async || self2.readyState < self2.OPENED || self2.readyState === self2.DONE) {
+        self2.dispatchEvent("readystatechange");
+      }
+      if (self2.readyState === self2.DONE) {
+        let fire;
+        if (abortedFlag)
+          fire = "abort";
+        else if (errorFlag)
+          fire = "error";
+        else
+          fire = "load";
+        self2.dispatchEvent(fire);
+        self2.dispatchEvent("loadend");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/commons.js
+var PACKET_TYPES, PACKET_TYPES_REVERSE, ERROR_PACKET;
+var init_commons = __esm(() => {
+  PACKET_TYPES = Object.create(null);
+  PACKET_TYPES["open"] = "0";
+  PACKET_TYPES["close"] = "1";
+  PACKET_TYPES["ping"] = "2";
+  PACKET_TYPES["pong"] = "3";
+  PACKET_TYPES["message"] = "4";
+  PACKET_TYPES["upgrade"] = "5";
+  PACKET_TYPES["noop"] = "6";
+  PACKET_TYPES_REVERSE = Object.create(null);
+  Object.keys(PACKET_TYPES).forEach((key) => {
+    PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
   });
-  let init2;
+  ERROR_PACKET = { type: "error", data: "parser error" };
+});
+
+// ../../node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/encodePacket.js
+function encodePacketToBinary(packet, callback) {
+  if (packet.data instanceof ArrayBuffer || ArrayBuffer.isView(packet.data)) {
+    return callback(toBuffer(packet.data, false));
+  }
+  encodePacket(packet, true, (encoded) => {
+    if (!TEXT_ENCODER) {
+      TEXT_ENCODER = new TextEncoder;
+    }
+    callback(TEXT_ENCODER.encode(encoded));
+  });
+}
+var encodePacket = ({ type, data }, supportsBinary, callback) => {
+  if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+    return callback(supportsBinary ? data : "b" + toBuffer(data, true).toString("base64"));
+  }
+  return callback(PACKET_TYPES[type] + (data || ""));
+}, toBuffer = (data, forceBufferConversion) => {
+  if (Buffer.isBuffer(data) || data instanceof Uint8Array && !forceBufferConversion) {
+    return data;
+  } else if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  } else {
+    return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  }
+}, TEXT_ENCODER;
+var init_encodePacket = __esm(() => {
+  init_commons();
+});
+
+// ../../node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/decodePacket.js
+var decodePacket = (encodedPacket, binaryType) => {
+  if (typeof encodedPacket !== "string") {
+    return {
+      type: "message",
+      data: mapBinary(encodedPacket, binaryType)
+    };
+  }
+  const type = encodedPacket.charAt(0);
+  if (type === "b") {
+    const buffer = Buffer.from(encodedPacket.substring(1), "base64");
+    return {
+      type: "message",
+      data: mapBinary(buffer, binaryType)
+    };
+  }
+  if (!PACKET_TYPES_REVERSE[type]) {
+    return ERROR_PACKET;
+  }
+  return encodedPacket.length > 1 ? {
+    type: PACKET_TYPES_REVERSE[type],
+    data: encodedPacket.substring(1)
+  } : {
+    type: PACKET_TYPES_REVERSE[type]
+  };
+}, mapBinary = (data, binaryType) => {
+  switch (binaryType) {
+    case "arraybuffer":
+      if (data instanceof ArrayBuffer) {
+        return data;
+      } else if (Buffer.isBuffer(data)) {
+        return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      } else {
+        return data.buffer;
+      }
+    case "nodebuffer":
+    default:
+      if (Buffer.isBuffer(data)) {
+        return data;
+      } else {
+        return Buffer.from(data);
+      }
+  }
+};
+var init_decodePacket = __esm(() => {
+  init_commons();
+});
+
+// ../../node_modules/.pnpm/engine.io-parser@5.2.3/node_modules/engine.io-parser/build/esm/index.js
+function createPacketEncoderStream() {
+  return new TransformStream({
+    transform(packet, controller) {
+      encodePacketToBinary(packet, (encodedPacket) => {
+        const payloadLength = encodedPacket.length;
+        let header;
+        if (payloadLength < 126) {
+          header = new Uint8Array(1);
+          new DataView(header.buffer).setUint8(0, payloadLength);
+        } else if (payloadLength < 65536) {
+          header = new Uint8Array(3);
+          const view = new DataView(header.buffer);
+          view.setUint8(0, 126);
+          view.setUint16(1, payloadLength);
+        } else {
+          header = new Uint8Array(9);
+          const view = new DataView(header.buffer);
+          view.setUint8(0, 127);
+          view.setBigUint64(1, BigInt(payloadLength));
+        }
+        if (packet.data && typeof packet.data !== "string") {
+          header[0] |= 128;
+        }
+        controller.enqueue(header);
+        controller.enqueue(encodedPacket);
+      });
+    }
+  });
+}
+function totalLength(chunks) {
+  return chunks.reduce((acc, chunk2) => acc + chunk2.length, 0);
+}
+function concatChunks(chunks, size9) {
+  if (chunks[0].length === size9) {
+    return chunks.shift();
+  }
+  const buffer = new Uint8Array(size9);
+  let j = 0;
+  for (let i2 = 0;i2 < size9; i2++) {
+    buffer[i2] = chunks[0][j++];
+    if (j === chunks[0].length) {
+      chunks.shift();
+      j = 0;
+    }
+  }
+  if (chunks.length && j < chunks[0].length) {
+    chunks[0] = chunks[0].slice(j);
+  }
+  return buffer;
+}
+function createPacketDecoderStream(maxPayload, binaryType) {
+  if (!TEXT_DECODER) {
+    TEXT_DECODER = new TextDecoder;
+  }
+  const chunks = [];
+  let state = 0;
+  let expectedLength = -1;
+  let isBinary = false;
+  return new TransformStream({
+    transform(chunk2, controller) {
+      chunks.push(chunk2);
+      while (true) {
+        if (state === 0) {
+          if (totalLength(chunks) < 1) {
+            break;
+          }
+          const header = concatChunks(chunks, 1);
+          isBinary = (header[0] & 128) === 128;
+          expectedLength = header[0] & 127;
+          if (expectedLength < 126) {
+            state = 3;
+          } else if (expectedLength === 126) {
+            state = 1;
+          } else {
+            state = 2;
+          }
+        } else if (state === 1) {
+          if (totalLength(chunks) < 2) {
+            break;
+          }
+          const headerArray = concatChunks(chunks, 2);
+          expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
+          state = 3;
+        } else if (state === 2) {
+          if (totalLength(chunks) < 8) {
+            break;
+          }
+          const headerArray = concatChunks(chunks, 8);
+          const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);
+          const n = view.getUint32(0);
+          if (n > Math.pow(2, 53 - 32) - 1) {
+            controller.enqueue(ERROR_PACKET);
+            break;
+          }
+          expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
+          state = 3;
+        } else {
+          if (totalLength(chunks) < expectedLength) {
+            break;
+          }
+          const data = concatChunks(chunks, expectedLength);
+          controller.enqueue(decodePacket(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
+          state = 0;
+        }
+        if (expectedLength === 0 || expectedLength > maxPayload) {
+          controller.enqueue(ERROR_PACKET);
+          break;
+        }
+      }
+    }
+  });
+}
+var SEPARATOR, encodePayload = (packets, callback) => {
+  const length2 = packets.length;
+  const encodedPackets = new Array(length2);
+  let count3 = 0;
+  packets.forEach((packet, i2) => {
+    encodePacket(packet, false, (encodedPacket) => {
+      encodedPackets[i2] = encodedPacket;
+      if (++count3 === length2) {
+        callback(encodedPackets.join(SEPARATOR));
+      }
+    });
+  });
+}, decodePayload = (encodedPayload, binaryType) => {
+  const encodedPackets = encodedPayload.split(SEPARATOR);
+  const packets = [];
+  for (let i2 = 0;i2 < encodedPackets.length; i2++) {
+    const decodedPacket = decodePacket(encodedPackets[i2], binaryType);
+    packets.push(decodedPacket);
+    if (decodedPacket.type === "error") {
+      break;
+    }
+  }
+  return packets;
+}, TEXT_DECODER, protocol = 4;
+var init_esm2 = __esm(() => {
+  init_encodePacket();
+  init_decodePacket();
+  init_commons();
+  SEPARATOR = String.fromCharCode(30);
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/globals.node.js
+function createCookieJar() {
+  return new CookieJar;
+}
+function parse8(setCookieString) {
+  const parts2 = setCookieString.split("; ");
+  const i2 = parts2[0].indexOf("=");
+  if (i2 === -1) {
+    return;
+  }
+  const name = parts2[0].substring(0, i2).trim();
+  if (!name.length) {
+    return;
+  }
+  let value = parts2[0].substring(i2 + 1).trim();
+  if (value.charCodeAt(0) === 34) {
+    value = value.slice(1, -1);
+  }
+  const cookie = {
+    name,
+    value
+  };
+  for (let j = 1;j < parts2.length; j++) {
+    const subParts = parts2[j].split("=");
+    if (subParts.length !== 2) {
+      continue;
+    }
+    const key = subParts[0].trim();
+    const value2 = subParts[1].trim();
+    switch (key) {
+      case "Expires":
+        cookie.expires = new Date(value2);
+        break;
+      case "Max-Age":
+        const expiration = new Date;
+        expiration.setUTCSeconds(expiration.getUTCSeconds() + parseInt(value2, 10));
+        cookie.expires = expiration;
+        break;
+      default:
+    }
+  }
+  return cookie;
+}
+
+class CookieJar {
+  constructor() {
+    this._cookies = new Map;
+  }
+  parseCookies(values3) {
+    if (!values3) {
+      return;
+    }
+    values3.forEach((value) => {
+      const parsed = parse8(value);
+      if (parsed) {
+        this._cookies.set(parsed.name, parsed);
+      }
+    });
+  }
+  get cookies() {
+    const now = Date.now();
+    this._cookies.forEach((cookie, name) => {
+      var _a4;
+      if (((_a4 = cookie.expires) === null || _a4 === undefined ? undefined : _a4.getTime()) < now) {
+        this._cookies.delete(name);
+      }
+    });
+    return this._cookies.entries();
+  }
+  addCookies(xhr) {
+    const cookies = [];
+    for (const [name, cookie] of this.cookies) {
+      cookies.push(`${name}=${cookie.value}`);
+    }
+    if (cookies.length) {
+      xhr.setDisableHeaderCheck(true);
+      xhr.setRequestHeader("cookie", cookies.join("; "));
+    }
+  }
+  appendCookies(headers) {
+    for (const [name, cookie] of this.cookies) {
+      headers.append("cookie", `${name}=${cookie.value}`);
+    }
+  }
+}
+var nextTick, globalThisShim, defaultBinaryType = "nodebuffer";
+var init_globals_node = __esm(() => {
+  nextTick = process.nextTick;
+  globalThisShim = global;
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/util.js
+function pick5(obj, ...attr) {
+  return attr.reduce((acc, k) => {
+    if (obj.hasOwnProperty(k)) {
+      acc[k] = obj[k];
+    }
+    return acc;
+  }, {});
+}
+function installTimerFunctions(obj, opts) {
+  if (opts.useNativeTimers) {
+    obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThisShim);
+    obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThisShim);
+  } else {
+    obj.setTimeoutFn = globalThisShim.setTimeout.bind(globalThisShim);
+    obj.clearTimeoutFn = globalThisShim.clearTimeout.bind(globalThisShim);
+  }
+}
+function byteLength2(obj) {
+  if (typeof obj === "string") {
+    return utf8Length(obj);
+  }
+  return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
+}
+function utf8Length(str) {
+  let c = 0, length2 = 0;
+  for (let i2 = 0, l = str.length;i2 < l; i2++) {
+    c = str.charCodeAt(i2);
+    if (c < 128) {
+      length2 += 1;
+    } else if (c < 2048) {
+      length2 += 2;
+    } else if (c < 55296 || c >= 57344) {
+      length2 += 3;
+    } else {
+      i2++;
+      length2 += 4;
+    }
+  }
+  return length2;
+}
+function randomString2() {
+  return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5);
+}
+var NATIVE_SET_TIMEOUT, NATIVE_CLEAR_TIMEOUT, BASE64_OVERHEAD = 1.33;
+var init_util3 = __esm(() => {
+  init_globals_node();
+  NATIVE_SET_TIMEOUT = globalThisShim.setTimeout;
+  NATIVE_CLEAR_TIMEOUT = globalThisShim.clearTimeout;
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/contrib/parseqs.js
+function encode5(obj) {
+  let str = "";
+  for (let i2 in obj) {
+    if (obj.hasOwnProperty(i2)) {
+      if (str.length)
+        str += "&";
+      str += encodeURIComponent(i2) + "=" + encodeURIComponent(obj[i2]);
+    }
+  }
+  return str;
+}
+function decode5(qs) {
+  let qry = {};
+  let pairs = qs.split("&");
+  for (let i2 = 0, l = pairs.length;i2 < l; i2++) {
+    let pair = pairs[i2].split("=");
+    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
+  }
+  return qry;
+}
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transport.js
+var import_component_emitter, import_debug2, debug2, TransportError, Transport;
+var init_transport2 = __esm(() => {
+  init_esm2();
+  init_util3();
+  import_component_emitter = __toESM(require_cjs2(), 1);
+  import_debug2 = __toESM(require_src2(), 1);
+  debug2 = import_debug2.default("engine.io-client:transport");
+  TransportError = class TransportError extends Error {
+    constructor(reason, description, context5) {
+      super(reason);
+      this.description = description;
+      this.context = context5;
+      this.type = "TransportError";
+    }
+  };
+  Transport = class Transport extends import_component_emitter.Emitter {
+    constructor(opts) {
+      super();
+      this.writable = false;
+      installTimerFunctions(this, opts);
+      this.opts = opts;
+      this.query = opts.query;
+      this.socket = opts.socket;
+      this.supportsBinary = !opts.forceBase64;
+    }
+    onError(reason, description, context5) {
+      super.emitReserved("error", new TransportError(reason, description, context5));
+      return this;
+    }
+    open() {
+      this.readyState = "opening";
+      this.doOpen();
+      return this;
+    }
+    close() {
+      if (this.readyState === "opening" || this.readyState === "open") {
+        this.doClose();
+        this.onClose();
+      }
+      return this;
+    }
+    send(packets) {
+      if (this.readyState === "open") {
+        this.write(packets);
+      } else {
+        debug2("transport is not open, discarding packets");
+      }
+    }
+    onOpen() {
+      this.readyState = "open";
+      this.writable = true;
+      super.emitReserved("open");
+    }
+    onData(data) {
+      const packet = decodePacket(data, this.socket.binaryType);
+      this.onPacket(packet);
+    }
+    onPacket(packet) {
+      super.emitReserved("packet", packet);
+    }
+    onClose(details) {
+      this.readyState = "closed";
+      super.emitReserved("close", details);
+    }
+    pause(onPause) {}
+    createUri(schema, query = {}) {
+      return schema + "://" + this._hostname() + this._port() + this.opts.path + this._query(query);
+    }
+    _hostname() {
+      const hostname5 = this.opts.hostname;
+      return hostname5.indexOf(":") === -1 ? hostname5 : "[" + hostname5 + "]";
+    }
+    _port() {
+      if (this.opts.port && (this.opts.secure && Number(this.opts.port) !== 443 || !this.opts.secure && Number(this.opts.port) !== 80)) {
+        return ":" + this.opts.port;
+      } else {
+        return "";
+      }
+    }
+    _query(query) {
+      const encodedQuery = encode5(query);
+      return encodedQuery.length ? "?" + encodedQuery : "";
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transports/polling.js
+var import_debug3, debug3, Polling;
+var init_polling = __esm(() => {
+  init_transport2();
+  init_util3();
+  init_esm2();
+  import_debug3 = __toESM(require_src2(), 1);
+  debug3 = import_debug3.default("engine.io-client:polling");
+  Polling = class Polling extends Transport {
+    constructor() {
+      super(...arguments);
+      this._polling = false;
+    }
+    get name() {
+      return "polling";
+    }
+    doOpen() {
+      this._poll();
+    }
+    pause(onPause) {
+      this.readyState = "pausing";
+      const pause = () => {
+        debug3("paused");
+        this.readyState = "paused";
+        onPause();
+      };
+      if (this._polling || !this.writable) {
+        let total = 0;
+        if (this._polling) {
+          debug3("we are currently polling - waiting to pause");
+          total++;
+          this.once("pollComplete", function() {
+            debug3("pre-pause polling complete");
+            --total || pause();
+          });
+        }
+        if (!this.writable) {
+          debug3("we are currently writing - waiting to pause");
+          total++;
+          this.once("drain", function() {
+            debug3("pre-pause writing complete");
+            --total || pause();
+          });
+        }
+      } else {
+        pause();
+      }
+    }
+    _poll() {
+      debug3("polling");
+      this._polling = true;
+      this.doPoll();
+      this.emitReserved("poll");
+    }
+    onData(data) {
+      debug3("polling got data %s", data);
+      const callback = (packet) => {
+        if (this.readyState === "opening" && packet.type === "open") {
+          this.onOpen();
+        }
+        if (packet.type === "close") {
+          this.onClose({ description: "transport closed by the server" });
+          return false;
+        }
+        this.onPacket(packet);
+      };
+      decodePayload(data, this.socket.binaryType).forEach(callback);
+      if (this.readyState !== "closed") {
+        this._polling = false;
+        this.emitReserved("pollComplete");
+        if (this.readyState === "open") {
+          this._poll();
+        } else {
+          debug3('ignoring poll - transport state "%s"', this.readyState);
+        }
+      }
+    }
+    doClose() {
+      const close2 = () => {
+        debug3("writing close packet");
+        this.write([{ type: "close" }]);
+      };
+      if (this.readyState === "open") {
+        debug3("transport open - closing");
+        close2();
+      } else {
+        debug3("transport not open - deferring close");
+        this.once("open", close2);
+      }
+    }
+    write(packets) {
+      this.writable = false;
+      encodePayload(packets, (data) => {
+        this.doWrite(data, () => {
+          this.writable = true;
+          this.emitReserved("drain");
+        });
+      });
+    }
+    uri() {
+      const schema = this.opts.secure ? "https" : "http";
+      const query = this.query || {};
+      if (this.opts.timestampRequests !== false) {
+        query[this.opts.timestampParam] = randomString2();
+      }
+      if (!this.supportsBinary && !query.sid) {
+        query.b64 = 1;
+      }
+      return this.createUri(schema, query);
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/contrib/has-cors.js
+var value = false, hasCORS;
+var init_has_cors = __esm(() => {
+  try {
+    value = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest;
+  } catch (err) {}
+  hasCORS = value;
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.js
+function empty30() {}
+function unloadHandler() {
+  for (let i2 in Request3.requests) {
+    if (Request3.requests.hasOwnProperty(i2)) {
+      Request3.requests[i2].abort();
+    }
+  }
+}
+function newRequest(opts) {
+  const xdomain = opts.xdomain;
   try {
-    init2 = await initDaemon({ logSink: logServer });
+    if (typeof XMLHttpRequest !== "undefined" && (!xdomain || hasCORS)) {
+      return new XMLHttpRequest;
+    }
+  } catch (e) {}
+  if (!xdomain) {
+    try {
+      return new globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+    } catch (e) {}
+  }
+}
+var import_component_emitter2, import_debug4, debug4, BaseXHR, Request3, hasXHR2;
+var init_polling_xhr = __esm(() => {
+  init_polling();
+  init_util3();
+  init_globals_node();
+  init_has_cors();
+  import_component_emitter2 = __toESM(require_cjs2(), 1);
+  import_debug4 = __toESM(require_src2(), 1);
+  debug4 = import_debug4.default("engine.io-client:polling");
+  BaseXHR = class BaseXHR extends Polling {
+    constructor(opts) {
+      super(opts);
+      if (typeof location !== "undefined") {
+        const isSSL = location.protocol === "https:";
+        let port = location.port;
+        if (!port) {
+          port = isSSL ? "443" : "80";
+        }
+        this.xd = typeof location !== "undefined" && opts.hostname !== location.hostname || port !== opts.port;
+      }
+    }
+    doWrite(data, fn2) {
+      const req = this.request({
+        method: "POST",
+        data
+      });
+      req.on("success", fn2);
+      req.on("error", (xhrStatus, context5) => {
+        this.onError("xhr post error", xhrStatus, context5);
+      });
+    }
+    doPoll() {
+      debug4("xhr poll");
+      const req = this.request();
+      req.on("data", this.onData.bind(this));
+      req.on("error", (xhrStatus, context5) => {
+        this.onError("xhr poll error", xhrStatus, context5);
+      });
+      this.pollXhr = req;
+    }
+  };
+  Request3 = class Request3 extends import_component_emitter2.Emitter {
+    constructor(createRequest, uri, opts) {
+      super();
+      this.createRequest = createRequest;
+      installTimerFunctions(this, opts);
+      this._opts = opts;
+      this._method = opts.method || "GET";
+      this._uri = uri;
+      this._data = opts.data !== undefined ? opts.data : null;
+      this._create();
+    }
+    _create() {
+      var _a4;
+      const opts = pick5(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+      opts.xdomain = !!this._opts.xd;
+      const xhr = this._xhr = this.createRequest(opts);
+      try {
+        debug4("xhr open %s: %s", this._method, this._uri);
+        xhr.open(this._method, this._uri, true);
+        try {
+          if (this._opts.extraHeaders) {
+            xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
+            for (let i2 in this._opts.extraHeaders) {
+              if (this._opts.extraHeaders.hasOwnProperty(i2)) {
+                xhr.setRequestHeader(i2, this._opts.extraHeaders[i2]);
+              }
+            }
+          }
+        } catch (e) {}
+        if (this._method === "POST") {
+          try {
+            xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+          } catch (e) {}
+        }
+        try {
+          xhr.setRequestHeader("Accept", "*/*");
+        } catch (e) {}
+        (_a4 = this._opts.cookieJar) === null || _a4 === undefined || _a4.addCookies(xhr);
+        if ("withCredentials" in xhr) {
+          xhr.withCredentials = this._opts.withCredentials;
+        }
+        if (this._opts.requestTimeout) {
+          xhr.timeout = this._opts.requestTimeout;
+        }
+        xhr.onreadystatechange = () => {
+          var _a5;
+          if (xhr.readyState === 3) {
+            (_a5 = this._opts.cookieJar) === null || _a5 === undefined || _a5.parseCookies(xhr.getResponseHeader("set-cookie"));
+          }
+          if (xhr.readyState !== 4)
+            return;
+          if (xhr.status === 200 || xhr.status === 1223) {
+            this._onLoad();
+          } else {
+            this.setTimeoutFn(() => {
+              this._onError(typeof xhr.status === "number" ? xhr.status : 0);
+            }, 0);
+          }
+        };
+        debug4("xhr data %s", this._data);
+        xhr.send(this._data);
+      } catch (e) {
+        this.setTimeoutFn(() => {
+          this._onError(e);
+        }, 0);
+        return;
+      }
+      if (typeof document !== "undefined") {
+        this._index = Request3.requestsCount++;
+        Request3.requests[this._index] = this;
+      }
+    }
+    _onError(err) {
+      this.emitReserved("error", err, this._xhr);
+      this._cleanup(true);
+    }
+    _cleanup(fromError) {
+      if (typeof this._xhr === "undefined" || this._xhr === null) {
+        return;
+      }
+      this._xhr.onreadystatechange = empty30;
+      if (fromError) {
+        try {
+          this._xhr.abort();
+        } catch (e) {}
+      }
+      if (typeof document !== "undefined") {
+        delete Request3.requests[this._index];
+      }
+      this._xhr = null;
+    }
+    _onLoad() {
+      const data = this._xhr.responseText;
+      if (data !== null) {
+        this.emitReserved("data", data);
+        this.emitReserved("success");
+        this._cleanup();
+      }
+    }
+    abort() {
+      this._cleanup();
+    }
+  };
+  Request3.requestsCount = 0;
+  Request3.requests = {};
+  if (typeof document !== "undefined") {
+    if (typeof attachEvent === "function") {
+      attachEvent("onunload", unloadHandler);
+    } else if (typeof addEventListener === "function") {
+      const terminationEvent = "onpagehide" in globalThisShim ? "pagehide" : "unload";
+      addEventListener(terminationEvent, unloadHandler, false);
+    }
+  }
+  hasXHR2 = function() {
+    const xhr = newRequest({
+      xdomain: false
+    });
+    return xhr && xhr.responseType !== null;
+  }();
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.node.js
+var XMLHttpRequestModule, XMLHttpRequest2, XHR;
+var init_polling_xhr_node = __esm(() => {
+  init_polling_xhr();
+  XMLHttpRequestModule = __toESM(require_XMLHttpRequest(), 1);
+  XMLHttpRequest2 = XMLHttpRequestModule.default || XMLHttpRequestModule;
+  XHR = class XHR extends BaseXHR {
+    request(opts = {}) {
+      var _a4;
+      Object.assign(opts, { xd: this.xd, cookieJar: (_a4 = this.socket) === null || _a4 === undefined ? undefined : _a4._cookieJar }, this.opts);
+      return new Request3((opts2) => new XMLHttpRequest2(opts2), this.uri(), opts);
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
+var import_stream13, import_extension2, import_permessage_deflate2, import_receiver2, import_sender2, import_subprotocol2, import_websocket2, import_websocket_server2;
+var init_wrapper2 = __esm(() => {
+  import_stream13 = __toESM(require_stream2(), 1);
+  import_extension2 = __toESM(require_extension2(), 1);
+  import_permessage_deflate2 = __toESM(require_permessage_deflate2(), 1);
+  import_receiver2 = __toESM(require_receiver2(), 1);
+  import_sender2 = __toESM(require_sender2(), 1);
+  import_subprotocol2 = __toESM(require_subprotocol2(), 1);
+  import_websocket2 = __toESM(require_websocket3(), 1);
+  import_websocket_server2 = __toESM(require_websocket_server2(), 1);
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transports/websocket.js
+var import_debug5, debug5, isReactNative2, BaseWS, WebSocketCtor;
+var init_websocket = __esm(() => {
+  init_transport2();
+  init_util3();
+  init_esm2();
+  init_globals_node();
+  import_debug5 = __toESM(require_src2(), 1);
+  debug5 = import_debug5.default("engine.io-client:websocket");
+  isReactNative2 = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
+  BaseWS = class BaseWS extends Transport {
+    get name() {
+      return "websocket";
+    }
+    doOpen() {
+      const uri = this.uri();
+      const protocols = this.opts.protocols;
+      const opts = isReactNative2 ? {} : pick5(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
+      if (this.opts.extraHeaders) {
+        opts.headers = this.opts.extraHeaders;
+      }
+      try {
+        this.ws = this.createSocket(uri, protocols, opts);
+      } catch (err) {
+        return this.emitReserved("error", err);
+      }
+      this.ws.binaryType = this.socket.binaryType;
+      this.addEventListeners();
+    }
+    addEventListeners() {
+      this.ws.onopen = () => {
+        if (this.opts.autoUnref) {
+          this.ws._socket.unref();
+        }
+        this.onOpen();
+      };
+      this.ws.onclose = (closeEvent) => this.onClose({
+        description: "websocket connection closed",
+        context: closeEvent
+      });
+      this.ws.onmessage = (ev) => this.onData(ev.data);
+      this.ws.onerror = (e) => this.onError("websocket error", e);
+    }
+    write(packets) {
+      this.writable = false;
+      for (let i2 = 0;i2 < packets.length; i2++) {
+        const packet = packets[i2];
+        const lastPacket = i2 === packets.length - 1;
+        encodePacket(packet, this.supportsBinary, (data) => {
+          try {
+            this.doWrite(packet, data);
+          } catch (e) {
+            debug5("websocket closed before onclose event");
+          }
+          if (lastPacket) {
+            nextTick(() => {
+              this.writable = true;
+              this.emitReserved("drain");
+            }, this.setTimeoutFn);
+          }
+        });
+      }
+    }
+    doClose() {
+      if (typeof this.ws !== "undefined") {
+        this.ws.onerror = () => {};
+        this.ws.close();
+        this.ws = null;
+      }
+    }
+    uri() {
+      const schema = this.opts.secure ? "wss" : "ws";
+      const query = this.query || {};
+      if (this.opts.timestampRequests) {
+        query[this.opts.timestampParam] = randomString2();
+      }
+      if (!this.supportsBinary) {
+        query.b64 = 1;
+      }
+      return this.createUri(schema, query);
+    }
+  };
+  WebSocketCtor = globalThisShim.WebSocket || globalThisShim.MozWebSocket;
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transports/websocket.node.js
+var WS;
+var init_websocket_node = __esm(() => {
+  init_wrapper2();
+  init_websocket();
+  WS = class WS extends BaseWS {
+    createSocket(uri, protocols, opts) {
+      var _a4;
+      if ((_a4 = this.socket) === null || _a4 === undefined ? undefined : _a4._cookieJar) {
+        opts.headers = opts.headers || {};
+        opts.headers.cookie = typeof opts.headers.cookie === "string" ? [opts.headers.cookie] : opts.headers.cookie || [];
+        for (const [name, cookie] of this.socket._cookieJar.cookies) {
+          opts.headers.cookie.push(`${name}=${cookie.value}`);
+        }
+      }
+      return new import_websocket2.default(uri, protocols, opts);
+    }
+    doWrite(packet, data) {
+      const opts = {};
+      if (packet.options) {
+        opts.compress = packet.options.compress;
+      }
+      if (this.opts.perMessageDeflate) {
+        const len2 = typeof data === "string" ? Buffer.byteLength(data) : data.length;
+        if (len2 < this.opts.perMessageDeflate.threshold) {
+          opts.compress = false;
+        }
+      }
+      this.ws.send(data, opts);
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transports/webtransport.js
+var import_debug6, debug6, WT;
+var init_webtransport = __esm(() => {
+  init_transport2();
+  init_globals_node();
+  init_esm2();
+  import_debug6 = __toESM(require_src2(), 1);
+  debug6 = import_debug6.default("engine.io-client:webtransport");
+  WT = class WT extends Transport {
+    get name() {
+      return "webtransport";
+    }
+    doOpen() {
+      try {
+        this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+      } catch (err) {
+        return this.emitReserved("error", err);
+      }
+      this._transport.closed.then(() => {
+        debug6("transport closed gracefully");
+        this.onClose();
+      }).catch((err) => {
+        debug6("transport closed due to %s", err);
+        this.onError("webtransport error", err);
+      });
+      this._transport.ready.then(() => {
+        this._transport.createBidirectionalStream().then((stream4) => {
+          const decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
+          const reader = stream4.readable.pipeThrough(decoderStream).getReader();
+          const encoderStream = createPacketEncoderStream();
+          encoderStream.readable.pipeTo(stream4.writable);
+          this._writer = encoderStream.writable.getWriter();
+          const read = () => {
+            reader.read().then(({ done: done9, value: value2 }) => {
+              if (done9) {
+                debug6("session is closed");
+                return;
+              }
+              debug6("received chunk: %o", value2);
+              this.onPacket(value2);
+              read();
+            }).catch((err) => {
+              debug6("an error occurred while reading: %s", err);
+            });
+          };
+          read();
+          const packet = { type: "open" };
+          if (this.query.sid) {
+            packet.data = `{"sid":"${this.query.sid}"}`;
+          }
+          this._writer.write(packet).then(() => this.onOpen());
+        });
+      });
+    }
+    write(packets) {
+      this.writable = false;
+      for (let i2 = 0;i2 < packets.length; i2++) {
+        const packet = packets[i2];
+        const lastPacket = i2 === packets.length - 1;
+        this._writer.write(packet).then(() => {
+          if (lastPacket) {
+            nextTick(() => {
+              this.writable = true;
+              this.emitReserved("drain");
+            }, this.setTimeoutFn);
+          }
+        });
+      }
+    }
+    doClose() {
+      var _a4;
+      (_a4 = this._transport) === null || _a4 === undefined || _a4.close();
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transports/index.js
+var transports;
+var init_transports = __esm(() => {
+  init_polling_xhr_node();
+  init_websocket_node();
+  init_webtransport();
+  transports = {
+    websocket: WS,
+    webtransport: WT,
+    polling: XHR
+  };
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/contrib/parseuri.js
+function parse9(str) {
+  if (str.length > 8000) {
+    throw "URI too long";
+  }
+  const src = str, b = str.indexOf("["), e = str.indexOf("]");
+  if (b != -1 && e != -1) {
+    str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ";") + str.substring(e, str.length);
+  }
+  let m = re.exec(str || ""), uri = {}, i2 = 14;
+  while (i2--) {
+    uri[parts2[i2]] = m[i2] || "";
+  }
+  if (b != -1 && e != -1) {
+    uri.source = src;
+    uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ":");
+    uri.authority = uri.authority.replace("[", "").replace("]", "").replace(/;/g, ":");
+    uri.ipv6uri = true;
+  }
+  uri.pathNames = pathNames(uri, uri["path"]);
+  uri.queryKey = queryKey(uri, uri["query"]);
+  return uri;
+}
+function pathNames(obj, path8) {
+  const regx = /\/{2,9}/g, names = path8.replace(regx, "/").split("/");
+  if (path8.slice(0, 1) == "/" || path8.length === 0) {
+    names.splice(0, 1);
+  }
+  if (path8.slice(-1) == "/") {
+    names.splice(names.length - 1, 1);
+  }
+  return names;
+}
+function queryKey(uri, query) {
+  const data = {};
+  query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function($0, $1, $2) {
+    if ($1) {
+      data[$1] = $2;
+    }
+  });
+  return data;
+}
+var re, parts2;
+var init_parseuri = __esm(() => {
+  re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
+  parts2 = [
+    "source",
+    "protocol",
+    "authority",
+    "userInfo",
+    "user",
+    "password",
+    "host",
+    "port",
+    "relative",
+    "path",
+    "directory",
+    "file",
+    "query",
+    "anchor"
+  ];
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/socket.js
+var import_component_emitter3, import_debug7, debug7, withEventListeners, OFFLINE_EVENT_LISTENERS, SocketWithoutUpgrade, SocketWithUpgrade, Socket2;
+var init_socket = __esm(() => {
+  init_transports();
+  init_util3();
+  init_parseuri();
+  init_esm2();
+  init_globals_node();
+  import_component_emitter3 = __toESM(require_cjs2(), 1);
+  import_debug7 = __toESM(require_src2(), 1);
+  debug7 = import_debug7.default("engine.io-client:socket");
+  withEventListeners = typeof addEventListener === "function" && typeof removeEventListener === "function";
+  OFFLINE_EVENT_LISTENERS = [];
+  if (withEventListeners) {
+    addEventListener("offline", () => {
+      debug7("closing %d connection(s) because the network was lost", OFFLINE_EVENT_LISTENERS.length);
+      OFFLINE_EVENT_LISTENERS.forEach((listener) => listener());
+    }, false);
+  }
+  SocketWithoutUpgrade = class SocketWithoutUpgrade extends import_component_emitter3.Emitter {
+    constructor(uri, opts) {
+      super();
+      this.binaryType = defaultBinaryType;
+      this.writeBuffer = [];
+      this._prevBufferLen = 0;
+      this._pingInterval = -1;
+      this._pingTimeout = -1;
+      this._maxPayload = -1;
+      this._pingTimeoutTime = Infinity;
+      if (uri && typeof uri === "object") {
+        opts = uri;
+        uri = null;
+      }
+      if (uri) {
+        const parsedUri = parse9(uri);
+        opts.hostname = parsedUri.host;
+        opts.secure = parsedUri.protocol === "https" || parsedUri.protocol === "wss";
+        opts.port = parsedUri.port;
+        if (parsedUri.query)
+          opts.query = parsedUri.query;
+      } else if (opts.host) {
+        opts.hostname = parse9(opts.host).host;
+      }
+      installTimerFunctions(this, opts);
+      this.secure = opts.secure != null ? opts.secure : typeof location !== "undefined" && location.protocol === "https:";
+      if (opts.hostname && !opts.port) {
+        opts.port = this.secure ? "443" : "80";
+      }
+      this.hostname = opts.hostname || (typeof location !== "undefined" ? location.hostname : "localhost");
+      this.port = opts.port || (typeof location !== "undefined" && location.port ? location.port : this.secure ? "443" : "80");
+      this.transports = [];
+      this._transportsByName = {};
+      opts.transports.forEach((t) => {
+        const transportName = t.prototype.name;
+        this.transports.push(transportName);
+        this._transportsByName[transportName] = t;
+      });
+      this.opts = Object.assign({
+        path: "/engine.io",
+        agent: false,
+        withCredentials: false,
+        upgrade: true,
+        timestampParam: "t",
+        rememberUpgrade: false,
+        addTrailingSlash: true,
+        rejectUnauthorized: true,
+        perMessageDeflate: {
+          threshold: 1024
+        },
+        transportOptions: {},
+        closeOnBeforeunload: false
+      }, opts);
+      this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : "");
+      if (typeof this.opts.query === "string") {
+        this.opts.query = decode5(this.opts.query);
+      }
+      if (withEventListeners) {
+        if (this.opts.closeOnBeforeunload) {
+          this._beforeunloadEventListener = () => {
+            if (this.transport) {
+              this.transport.removeAllListeners();
+              this.transport.close();
+            }
+          };
+          addEventListener("beforeunload", this._beforeunloadEventListener, false);
+        }
+        if (this.hostname !== "localhost") {
+          debug7("adding listener for the 'offline' event");
+          this._offlineEventListener = () => {
+            this._onClose("transport close", {
+              description: "network connection lost"
+            });
+          };
+          OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);
+        }
+      }
+      if (this.opts.withCredentials) {
+        this._cookieJar = createCookieJar();
+      }
+      this._open();
+    }
+    createTransport(name) {
+      debug7('creating transport "%s"', name);
+      const query = Object.assign({}, this.opts.query);
+      query.EIO = protocol;
+      query.transport = name;
+      if (this.id)
+        query.sid = this.id;
+      const opts = Object.assign({}, this.opts, {
+        query,
+        socket: this,
+        hostname: this.hostname,
+        secure: this.secure,
+        port: this.port
+      }, this.opts.transportOptions[name]);
+      debug7("options: %j", opts);
+      return new this._transportsByName[name](opts);
+    }
+    _open() {
+      if (this.transports.length === 0) {
+        this.setTimeoutFn(() => {
+          this.emitReserved("error", "No transports available");
+        }, 0);
+        return;
+      }
+      const transportName = this.opts.rememberUpgrade && SocketWithoutUpgrade.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0];
+      this.readyState = "opening";
+      const transport2 = this.createTransport(transportName);
+      transport2.open();
+      this.setTransport(transport2);
+    }
+    setTransport(transport2) {
+      debug7("setting transport %s", transport2.name);
+      if (this.transport) {
+        debug7("clearing existing transport %s", this.transport.name);
+        this.transport.removeAllListeners();
+      }
+      this.transport = transport2;
+      transport2.on("drain", this._onDrain.bind(this)).on("packet", this._onPacket.bind(this)).on("error", this._onError.bind(this)).on("close", (reason) => this._onClose("transport close", reason));
+    }
+    onOpen() {
+      debug7("socket open");
+      this.readyState = "open";
+      SocketWithoutUpgrade.priorWebsocketSuccess = this.transport.name === "websocket";
+      this.emitReserved("open");
+      this.flush();
+    }
+    _onPacket(packet) {
+      if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") {
+        debug7('socket receive: type "%s", data "%s"', packet.type, packet.data);
+        this.emitReserved("packet", packet);
+        this.emitReserved("heartbeat");
+        switch (packet.type) {
+          case "open":
+            this.onHandshake(JSON.parse(packet.data));
+            break;
+          case "ping":
+            this._sendPacket("pong");
+            this.emitReserved("ping");
+            this.emitReserved("pong");
+            this._resetPingTimeout();
+            break;
+          case "error":
+            const err = new Error("server error");
+            err.code = packet.data;
+            this._onError(err);
+            break;
+          case "message":
+            this.emitReserved("data", packet.data);
+            this.emitReserved("message", packet.data);
+            break;
+        }
+      } else {
+        debug7('packet received with socket readyState "%s"', this.readyState);
+      }
+    }
+    onHandshake(data) {
+      this.emitReserved("handshake", data);
+      this.id = data.sid;
+      this.transport.query.sid = data.sid;
+      this._pingInterval = data.pingInterval;
+      this._pingTimeout = data.pingTimeout;
+      this._maxPayload = data.maxPayload;
+      this.onOpen();
+      if (this.readyState === "closed")
+        return;
+      this._resetPingTimeout();
+    }
+    _resetPingTimeout() {
+      this.clearTimeoutFn(this._pingTimeoutTimer);
+      const delay3 = this._pingInterval + this._pingTimeout;
+      this._pingTimeoutTime = Date.now() + delay3;
+      this._pingTimeoutTimer = this.setTimeoutFn(() => {
+        this._onClose("ping timeout");
+      }, delay3);
+      if (this.opts.autoUnref) {
+        this._pingTimeoutTimer.unref();
+      }
+    }
+    _onDrain() {
+      this.writeBuffer.splice(0, this._prevBufferLen);
+      this._prevBufferLen = 0;
+      if (this.writeBuffer.length === 0) {
+        this.emitReserved("drain");
+      } else {
+        this.flush();
+      }
+    }
+    flush() {
+      if (this.readyState !== "closed" && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
+        const packets = this._getWritablePackets();
+        debug7("flushing %d packets in socket", packets.length);
+        this.transport.send(packets);
+        this._prevBufferLen = packets.length;
+        this.emitReserved("flush");
+      }
+    }
+    _getWritablePackets() {
+      const shouldCheckPayloadSize = this._maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1;
+      if (!shouldCheckPayloadSize) {
+        return this.writeBuffer;
+      }
+      let payloadSize = 1;
+      for (let i2 = 0;i2 < this.writeBuffer.length; i2++) {
+        const data = this.writeBuffer[i2].data;
+        if (data) {
+          payloadSize += byteLength2(data);
+        }
+        if (i2 > 0 && payloadSize > this._maxPayload) {
+          debug7("only send %d out of %d packets", i2, this.writeBuffer.length);
+          return this.writeBuffer.slice(0, i2);
+        }
+        payloadSize += 2;
+      }
+      debug7("payload size is %d (max: %d)", payloadSize, this._maxPayload);
+      return this.writeBuffer;
+    }
+    _hasPingExpired() {
+      if (!this._pingTimeoutTime)
+        return true;
+      const hasExpired = Date.now() > this._pingTimeoutTime;
+      if (hasExpired) {
+        debug7("throttled timer detected, scheduling connection close");
+        this._pingTimeoutTime = 0;
+        nextTick(() => {
+          this._onClose("ping timeout");
+        }, this.setTimeoutFn);
+      }
+      return hasExpired;
+    }
+    write(msg, options, fn2) {
+      this._sendPacket("message", msg, options, fn2);
+      return this;
+    }
+    send(msg, options, fn2) {
+      this._sendPacket("message", msg, options, fn2);
+      return this;
+    }
+    _sendPacket(type, data, options, fn2) {
+      if (typeof data === "function") {
+        fn2 = data;
+        data = undefined;
+      }
+      if (typeof options === "function") {
+        fn2 = options;
+        options = null;
+      }
+      if (this.readyState === "closing" || this.readyState === "closed") {
+        return;
+      }
+      options = options || {};
+      options.compress = options.compress !== false;
+      const packet = {
+        type,
+        data,
+        options
+      };
+      this.emitReserved("packetCreate", packet);
+      this.writeBuffer.push(packet);
+      if (fn2)
+        this.once("flush", fn2);
+      this.flush();
+    }
+    close() {
+      const close2 = () => {
+        this._onClose("forced close");
+        debug7("socket closing - telling transport to close");
+        this.transport.close();
+      };
+      const cleanupAndClose = () => {
+        this.off("upgrade", cleanupAndClose);
+        this.off("upgradeError", cleanupAndClose);
+        close2();
+      };
+      const waitForUpgrade = () => {
+        this.once("upgrade", cleanupAndClose);
+        this.once("upgradeError", cleanupAndClose);
+      };
+      if (this.readyState === "opening" || this.readyState === "open") {
+        this.readyState = "closing";
+        if (this.writeBuffer.length) {
+          this.once("drain", () => {
+            if (this.upgrading) {
+              waitForUpgrade();
+            } else {
+              close2();
+            }
+          });
+        } else if (this.upgrading) {
+          waitForUpgrade();
+        } else {
+          close2();
+        }
+      }
+      return this;
+    }
+    _onError(err) {
+      debug7("socket error %j", err);
+      SocketWithoutUpgrade.priorWebsocketSuccess = false;
+      if (this.opts.tryAllTransports && this.transports.length > 1 && this.readyState === "opening") {
+        debug7("trying next transport");
+        this.transports.shift();
+        return this._open();
+      }
+      this.emitReserved("error", err);
+      this._onClose("transport error", err);
+    }
+    _onClose(reason, description) {
+      if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") {
+        debug7('socket close with reason: "%s"', reason);
+        this.clearTimeoutFn(this._pingTimeoutTimer);
+        this.transport.removeAllListeners("close");
+        this.transport.close();
+        this.transport.removeAllListeners();
+        if (withEventListeners) {
+          if (this._beforeunloadEventListener) {
+            removeEventListener("beforeunload", this._beforeunloadEventListener, false);
+          }
+          if (this._offlineEventListener) {
+            const i2 = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener);
+            if (i2 !== -1) {
+              debug7("removing listener for the 'offline' event");
+              OFFLINE_EVENT_LISTENERS.splice(i2, 1);
+            }
+          }
+        }
+        this.readyState = "closed";
+        this.id = null;
+        this.emitReserved("close", reason, description);
+        this.writeBuffer = [];
+        this._prevBufferLen = 0;
+      }
+    }
+  };
+  SocketWithoutUpgrade.protocol = protocol;
+  SocketWithUpgrade = class SocketWithUpgrade extends SocketWithoutUpgrade {
+    constructor() {
+      super(...arguments);
+      this._upgrades = [];
+    }
+    onOpen() {
+      super.onOpen();
+      if (this.readyState === "open" && this.opts.upgrade) {
+        debug7("starting upgrade probes");
+        for (let i2 = 0;i2 < this._upgrades.length; i2++) {
+          this._probe(this._upgrades[i2]);
+        }
+      }
+    }
+    _probe(name) {
+      debug7('probing transport "%s"', name);
+      let transport2 = this.createTransport(name);
+      let failed = false;
+      SocketWithoutUpgrade.priorWebsocketSuccess = false;
+      const onTransportOpen = () => {
+        if (failed)
+          return;
+        debug7('probe transport "%s" opened', name);
+        transport2.send([{ type: "ping", data: "probe" }]);
+        transport2.once("packet", (msg) => {
+          if (failed)
+            return;
+          if (msg.type === "pong" && msg.data === "probe") {
+            debug7('probe transport "%s" pong', name);
+            this.upgrading = true;
+            this.emitReserved("upgrading", transport2);
+            if (!transport2)
+              return;
+            SocketWithoutUpgrade.priorWebsocketSuccess = transport2.name === "websocket";
+            debug7('pausing current transport "%s"', this.transport.name);
+            this.transport.pause(() => {
+              if (failed)
+                return;
+              if (this.readyState === "closed")
+                return;
+              debug7("changing transport and sending upgrade packet");
+              cleanup();
+              this.setTransport(transport2);
+              transport2.send([{ type: "upgrade" }]);
+              this.emitReserved("upgrade", transport2);
+              transport2 = null;
+              this.upgrading = false;
+              this.flush();
+            });
+          } else {
+            debug7('probe transport "%s" failed', name);
+            const err = new Error("probe error");
+            err.transport = transport2.name;
+            this.emitReserved("upgradeError", err);
+          }
+        });
+      };
+      function freezeTransport() {
+        if (failed)
+          return;
+        failed = true;
+        cleanup();
+        transport2.close();
+        transport2 = null;
+      }
+      const onerror = (err) => {
+        const error51 = new Error("probe error: " + err);
+        error51.transport = transport2.name;
+        freezeTransport();
+        debug7('probe transport "%s" failed because of error: %s', name, err);
+        this.emitReserved("upgradeError", error51);
+      };
+      function onTransportClose() {
+        onerror("transport closed");
+      }
+      function onclose() {
+        onerror("socket closed");
+      }
+      function onupgrade(to) {
+        if (transport2 && to.name !== transport2.name) {
+          debug7('"%s" works - aborting "%s"', to.name, transport2.name);
+          freezeTransport();
+        }
+      }
+      const cleanup = () => {
+        transport2.removeListener("open", onTransportOpen);
+        transport2.removeListener("error", onerror);
+        transport2.removeListener("close", onTransportClose);
+        this.off("close", onclose);
+        this.off("upgrading", onupgrade);
+      };
+      transport2.once("open", onTransportOpen);
+      transport2.once("error", onerror);
+      transport2.once("close", onTransportClose);
+      this.once("close", onclose);
+      this.once("upgrading", onupgrade);
+      if (this._upgrades.indexOf("webtransport") !== -1 && name !== "webtransport") {
+        this.setTimeoutFn(() => {
+          if (!failed) {
+            transport2.open();
+          }
+        }, 200);
+      } else {
+        transport2.open();
+      }
+    }
+    onHandshake(data) {
+      this._upgrades = this._filterUpgrades(data.upgrades);
+      super.onHandshake(data);
+    }
+    _filterUpgrades(upgrades) {
+      const filteredUpgrades = [];
+      for (let i2 = 0;i2 < upgrades.length; i2++) {
+        if (~this.transports.indexOf(upgrades[i2]))
+          filteredUpgrades.push(upgrades[i2]);
+      }
+      return filteredUpgrades;
+    }
+  };
+  Socket2 = class Socket2 extends SocketWithUpgrade {
+    constructor(uri, opts = {}) {
+      const isOptionsOnly = typeof uri === "object";
+      const o = isOptionsOnly ? { ...uri } : { ...opts };
+      if (!o.transports || o.transports && typeof o.transports[0] === "string") {
+        o.transports = (o.transports || ["polling", "websocket", "webtransport"]).map((transportName) => transports[transportName]).filter((t) => !!t);
+      }
+      super(isOptionsOnly ? o : uri, o);
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/transports/polling-fetch.js
+var init_polling_fetch = __esm(() => {
+  init_polling();
+});
+
+// ../../node_modules/.pnpm/engine.io-client@6.6.6/node_modules/engine.io-client/build/esm-debug/index.js
+var protocol2;
+var init_esm_debug = __esm(() => {
+  init_socket();
+  init_socket();
+  init_transport2();
+  init_transports();
+  init_util3();
+  init_parseuri();
+  init_globals_node();
+  init_polling_fetch();
+  init_polling_xhr_node();
+  init_polling_xhr();
+  init_websocket_node();
+  init_websocket();
+  init_webtransport();
+  protocol2 = Socket2.protocol;
+});
+
+// ../../node_modules/.pnpm/socket.io-client@4.8.3/node_modules/socket.io-client/build/esm-debug/url.js
+function url3(uri, path8 = "", loc) {
+  let obj = uri;
+  loc = loc || typeof location !== "undefined" && location;
+  if (uri == null)
+    uri = loc.protocol + "//" + loc.host;
+  if (typeof uri === "string") {
+    if (uri.charAt(0) === "/") {
+      if (uri.charAt(1) === "/") {
+        uri = loc.protocol + uri;
+      } else {
+        uri = loc.host + uri;
+      }
+    }
+    if (!/^(https?|wss?):\/\//.test(uri)) {
+      debug8("protocol-less url %s", uri);
+      if (typeof loc !== "undefined") {
+        uri = loc.protocol + "//" + uri;
+      } else {
+        uri = "https://" + uri;
+      }
+    }
+    debug8("parse %s", uri);
+    obj = parse9(uri);
+  }
+  if (!obj.port) {
+    if (/^(http|ws)$/.test(obj.protocol)) {
+      obj.port = "80";
+    } else if (/^(http|ws)s$/.test(obj.protocol)) {
+      obj.port = "443";
+    }
+  }
+  obj.path = obj.path || "/";
+  const ipv63 = obj.host.indexOf(":") !== -1;
+  const host = ipv63 ? "[" + obj.host + "]" : obj.host;
+  obj.id = obj.protocol + "://" + host + ":" + obj.port + path8;
+  obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
+  return obj;
+}
+var import_debug8, debug8;
+var init_url = __esm(() => {
+  init_esm_debug();
+  import_debug8 = __toESM(require_src2(), 1);
+  debug8 = import_debug8.default("socket.io-client:url");
+});
+
+// ../../node_modules/.pnpm/socket.io-parser@4.2.7/node_modules/socket.io-parser/build/esm-debug/is-binary.js
+function isBinary(obj) {
+  return withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj)) || withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File;
+}
+function hasBinary(obj, toJSON2) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  if (Array.isArray(obj)) {
+    for (let i2 = 0, l = obj.length;i2 < l; i2++) {
+      if (hasBinary(obj[i2])) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (isBinary(obj)) {
+    return true;
+  }
+  if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) {
+    return hasBinary(obj.toJSON(), true);
+  }
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
+      return true;
+    }
+  }
+  return false;
+}
+var withNativeArrayBuffer, isView = (obj) => {
+  return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer;
+}, toString3, withNativeBlob, withNativeFile;
+var init_is_binary = __esm(() => {
+  withNativeArrayBuffer = typeof ArrayBuffer === "function";
+  toString3 = Object.prototype.toString;
+  withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && toString3.call(Blob) === "[object BlobConstructor]";
+  withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString3.call(File) === "[object FileConstructor]";
+});
+
+// ../../node_modules/.pnpm/socket.io-parser@4.2.7/node_modules/socket.io-parser/build/esm-debug/binary.js
+function deconstructPacket(packet) {
+  const buffers = [];
+  const packetData = packet.data;
+  const pack2 = packet;
+  pack2.data = _deconstructPacket(packetData, buffers);
+  pack2.attachments = buffers.length;
+  return { packet: pack2, buffers };
+}
+function _deconstructPacket(data, buffers, toJSON2) {
+  if (!data)
+    return data;
+  if (isBinary(data)) {
+    const placeholder = { _placeholder: true, num: buffers.length };
+    buffers.push(data);
+    return placeholder;
+  } else if (Array.isArray(data)) {
+    const newData = new Array(data.length);
+    for (let i2 = 0;i2 < data.length; i2++) {
+      newData[i2] = _deconstructPacket(data[i2], buffers);
+    }
+    return newData;
+  } else if (typeof data === "object" && !(data instanceof Date)) {
+    if (data.toJSON && typeof data.toJSON === "function" && !toJSON2) {
+      return _deconstructPacket(data.toJSON(), buffers, true);
+    }
+    const newData = {};
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        newData[key] = _deconstructPacket(data[key], buffers);
+      }
+    }
+    return newData;
+  }
+  return data;
+}
+function reconstructPacket(packet, buffers) {
+  packet.data = _reconstructPacket(packet.data, buffers);
+  delete packet.attachments;
+  return packet;
+}
+function _reconstructPacket(data, buffers) {
+  if (!data)
+    return data;
+  if (data && data._placeholder === true) {
+    const isIndexValid = typeof data.num === "number" && data.num >= 0 && data.num < buffers.length;
+    if (isIndexValid) {
+      return buffers[data.num];
+    } else {
+      throw new Error("illegal attachments");
+    }
+  } else if (Array.isArray(data)) {
+    for (let i2 = 0;i2 < data.length; i2++) {
+      data[i2] = _reconstructPacket(data[i2], buffers);
+    }
+  } else if (typeof data === "object") {
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        data[key] = _reconstructPacket(data[key], buffers);
+      }
+    }
+  }
+  return data;
+}
+var init_binary = __esm(() => {
+  init_is_binary();
+});
+
+// ../../node_modules/.pnpm/socket.io-parser@4.2.7/node_modules/socket.io-parser/build/esm-debug/index.js
+var exports_esm_debug = {};
+__export(exports_esm_debug, {
+  protocol: () => protocol3,
+  isPacketValid: () => isPacketValid,
+  PacketType: () => PacketType,
+  Encoder: () => Encoder,
+  Decoder: () => Decoder
+});
+
+class Encoder {
+  constructor(replacer) {
+    this.replacer = replacer;
+  }
+  encode(obj) {
+    debug9("encoding packet %j", obj);
+    if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
+      if (hasBinary(obj)) {
+        return this.encodeAsBinary({
+          type: obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK,
+          nsp: obj.nsp,
+          data: obj.data,
+          id: obj.id
+        });
+      }
+    }
+    return [this.encodeAsString(obj)];
+  }
+  encodeAsString(obj) {
+    let str = "" + obj.type;
+    if (obj.type === PacketType.BINARY_EVENT || obj.type === PacketType.BINARY_ACK) {
+      str += obj.attachments + "-";
+    }
+    if (obj.nsp && obj.nsp !== "/") {
+      str += obj.nsp + ",";
+    }
+    if (obj.id != null) {
+      str += obj.id;
+    }
+    if (obj.data != null) {
+      str += JSON.stringify(obj.data, this.replacer);
+    }
+    debug9("encoded %j as %s", obj, str);
+    return str;
+  }
+  encodeAsBinary(obj) {
+    const deconstruction = deconstructPacket(obj);
+    const pack2 = this.encodeAsString(deconstruction.packet);
+    const buffers = deconstruction.buffers;
+    buffers.unshift(pack2);
+    return buffers;
+  }
+}
+
+class BinaryReconstructor {
+  constructor(packet) {
+    this.packet = packet;
+    this.buffers = [];
+    this.reconPack = packet;
+  }
+  takeBinaryData(binData) {
+    this.buffers.push(binData);
+    if (this.buffers.length === this.reconPack.attachments) {
+      const packet = reconstructPacket(this.reconPack, this.buffers);
+      this.finishedReconstruction();
+      return packet;
+    }
+    return null;
+  }
+  finishedReconstruction() {
+    this.reconPack = null;
+    this.buffers = [];
+  }
+}
+function isNamespaceValid(nsp) {
+  return typeof nsp === "string";
+}
+function isAckIdValid(id3) {
+  return id3 === undefined || isInteger(id3);
+}
+function isObject4(value2) {
+  return Object.prototype.toString.call(value2) === "[object Object]";
+}
+function isDataValid(type, payload) {
+  switch (type) {
+    case PacketType.CONNECT:
+      return payload === undefined || isObject4(payload);
+    case PacketType.DISCONNECT:
+      return payload === undefined;
+    case PacketType.EVENT:
+      return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1);
+    case PacketType.ACK:
+      return Array.isArray(payload);
+    case PacketType.CONNECT_ERROR:
+      return typeof payload === "string" || isObject4(payload);
+    default:
+      return false;
+  }
+}
+function isPacketValid(packet) {
+  return isNamespaceValid(packet.nsp) && isAckIdValid(packet.id) && isDataValid(packet.type, packet.data);
+}
+var import_component_emitter4, import_debug9, debug9, RESERVED_EVENTS, protocol3 = 5, PacketType, Decoder, isInteger;
+var init_esm_debug2 = __esm(() => {
+  init_binary();
+  init_is_binary();
+  import_component_emitter4 = __toESM(require_cjs2(), 1);
+  import_debug9 = __toESM(require_src2(), 1);
+  debug9 = import_debug9.default("socket.io-parser");
+  RESERVED_EVENTS = [
+    "connect",
+    "connect_error",
+    "disconnect",
+    "disconnecting",
+    "newListener",
+    "removeListener"
+  ];
+  (function(PacketType2) {
+    PacketType2[PacketType2["CONNECT"] = 0] = "CONNECT";
+    PacketType2[PacketType2["DISCONNECT"] = 1] = "DISCONNECT";
+    PacketType2[PacketType2["EVENT"] = 2] = "EVENT";
+    PacketType2[PacketType2["ACK"] = 3] = "ACK";
+    PacketType2[PacketType2["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
+    PacketType2[PacketType2["BINARY_EVENT"] = 5] = "BINARY_EVENT";
+    PacketType2[PacketType2["BINARY_ACK"] = 6] = "BINARY_ACK";
+  })(PacketType || (PacketType = {}));
+  Decoder = class Decoder extends import_component_emitter4.Emitter {
+    constructor(opts) {
+      super();
+      this.opts = Object.assign({
+        reviver: undefined,
+        maxAttachments: 10
+      }, typeof opts === "function" ? { reviver: opts } : opts);
+    }
+    add(obj) {
+      let packet;
+      if (typeof obj === "string") {
+        if (this.reconstructor) {
+          throw new Error("got plaintext data when reconstructing a packet");
+        }
+        packet = this.decodeString(obj);
+        const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
+        if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
+          packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
+          this.reconstructor = new BinaryReconstructor(packet);
+        } else {
+          super.emitReserved("decoded", packet);
+        }
+      } else if (isBinary(obj) || obj.base64) {
+        if (!this.reconstructor) {
+          throw new Error("got binary data when not reconstructing a packet");
+        } else {
+          packet = this.reconstructor.takeBinaryData(obj);
+          if (packet) {
+            this.reconstructor = null;
+            super.emitReserved("decoded", packet);
+          }
+        }
+      } else {
+        throw new Error("Unknown type: " + obj);
+      }
+    }
+    decodeString(str) {
+      let i2 = 0;
+      const p = {
+        type: Number(str.charAt(0))
+      };
+      if (PacketType[p.type] === undefined) {
+        throw new Error("unknown packet type " + p.type);
+      }
+      if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) {
+        const start3 = i2 + 1;
+        while (str.charAt(++i2) !== "-" && i2 != str.length) {}
+        const buf = str.substring(start3, i2);
+        if (buf != Number(buf) || str.charAt(i2) !== "-") {
+          throw new Error("Illegal attachments");
+        }
+        const n = Number(buf);
+        if (!isInteger(n) || n < 1) {
+          throw new Error("Illegal attachments");
+        } else if (n > this.opts.maxAttachments) {
+          throw new Error("too many attachments");
+        }
+        p.attachments = n;
+      }
+      if (str.charAt(i2 + 1) === "/") {
+        const start3 = i2 + 1;
+        while (++i2) {
+          const c = str.charAt(i2);
+          if (c === ",")
+            break;
+          if (i2 === str.length)
+            break;
+        }
+        p.nsp = str.substring(start3, i2);
+      } else {
+        p.nsp = "/";
+      }
+      const next4 = str.charAt(i2 + 1);
+      if (next4 !== "" && Number(next4) == next4) {
+        const start3 = i2 + 1;
+        while (++i2) {
+          const c = str.charAt(i2);
+          if (c == null || Number(c) != c) {
+            --i2;
+            break;
+          }
+          if (i2 === str.length)
+            break;
+        }
+        p.id = Number(str.substring(start3, i2 + 1));
+      }
+      if (str.charAt(++i2)) {
+        const payload = this.tryParse(str.substr(i2));
+        if (Decoder.isPayloadValid(p.type, payload)) {
+          p.data = payload;
+        } else {
+          throw new Error("invalid payload");
+        }
+      }
+      debug9("decoded %s as %j", str, p);
+      return p;
+    }
+    tryParse(str) {
+      try {
+        return JSON.parse(str, this.opts.reviver);
+      } catch (e) {
+        return false;
+      }
+    }
+    static isPayloadValid(type, payload) {
+      switch (type) {
+        case PacketType.CONNECT:
+          return isObject4(payload);
+        case PacketType.DISCONNECT:
+          return payload === undefined;
+        case PacketType.CONNECT_ERROR:
+          return typeof payload === "string" || isObject4(payload);
+        case PacketType.EVENT:
+        case PacketType.BINARY_EVENT:
+          return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1);
+        case PacketType.ACK:
+        case PacketType.BINARY_ACK:
+          return Array.isArray(payload);
+      }
+    }
+    destroy() {
+      if (this.reconstructor) {
+        this.reconstructor.finishedReconstruction();
+        this.reconstructor = null;
+      }
+    }
+  };
+  isInteger = Number.isInteger || function(value2) {
+    return typeof value2 === "number" && isFinite(value2) && Math.floor(value2) === value2;
+  };
+});
+
+// ../../node_modules/.pnpm/socket.io-client@4.8.3/node_modules/socket.io-client/build/esm-debug/on.js
+function on(obj, ev, fn2) {
+  obj.on(ev, fn2);
+  return function subDestroy() {
+    obj.off(ev, fn2);
+  };
+}
+
+// ../../node_modules/.pnpm/socket.io-client@4.8.3/node_modules/socket.io-client/build/esm-debug/socket.js
+var import_component_emitter5, import_debug10, debug10, RESERVED_EVENTS2, Socket3;
+var init_socket2 = __esm(() => {
+  init_esm_debug2();
+  import_component_emitter5 = __toESM(require_cjs2(), 1);
+  import_debug10 = __toESM(require_src2(), 1);
+  debug10 = import_debug10.default("socket.io-client:socket");
+  RESERVED_EVENTS2 = Object.freeze({
+    connect: 1,
+    connect_error: 1,
+    disconnect: 1,
+    disconnecting: 1,
+    newListener: 1,
+    removeListener: 1
+  });
+  Socket3 = class Socket3 extends import_component_emitter5.Emitter {
+    constructor(io2, nsp, opts) {
+      super();
+      this.connected = false;
+      this.recovered = false;
+      this.receiveBuffer = [];
+      this.sendBuffer = [];
+      this._queue = [];
+      this._queueSeq = 0;
+      this.ids = 0;
+      this.acks = {};
+      this.flags = {};
+      this.io = io2;
+      this.nsp = nsp;
+      if (opts && opts.auth) {
+        this.auth = opts.auth;
+      }
+      this._opts = Object.assign({}, opts);
+      if (this.io._autoConnect)
+        this.open();
+    }
+    get disconnected() {
+      return !this.connected;
+    }
+    subEvents() {
+      if (this.subs)
+        return;
+      const io2 = this.io;
+      this.subs = [
+        on(io2, "open", this.onopen.bind(this)),
+        on(io2, "packet", this.onpacket.bind(this)),
+        on(io2, "error", this.onerror.bind(this)),
+        on(io2, "close", this.onclose.bind(this))
+      ];
+    }
+    get active() {
+      return !!this.subs;
+    }
+    connect() {
+      if (this.connected)
+        return this;
+      this.subEvents();
+      if (!this.io["_reconnecting"])
+        this.io.open();
+      if (this.io._readyState === "open")
+        this.onopen();
+      return this;
+    }
+    open() {
+      return this.connect();
+    }
+    send(...args2) {
+      args2.unshift("message");
+      this.emit.apply(this, args2);
+      return this;
+    }
+    emit(ev, ...args2) {
+      var _a4, _b2, _c;
+      if (RESERVED_EVENTS2.hasOwnProperty(ev)) {
+        throw new Error('"' + ev.toString() + '" is a reserved event name');
+      }
+      args2.unshift(ev);
+      if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
+        this._addToQueue(args2);
+        return this;
+      }
+      const packet = {
+        type: PacketType.EVENT,
+        data: args2
+      };
+      packet.options = {};
+      packet.options.compress = this.flags.compress !== false;
+      if (typeof args2[args2.length - 1] === "function") {
+        const id3 = this.ids++;
+        debug10("emitting packet with ack id %d", id3);
+        const ack = args2.pop();
+        this._registerAckCallback(id3, ack);
+        packet.id = id3;
+      }
+      const isTransportWritable = (_b2 = (_a4 = this.io.engine) === null || _a4 === undefined ? undefined : _a4.transport) === null || _b2 === undefined ? undefined : _b2.writable;
+      const isConnected = this.connected && !((_c = this.io.engine) === null || _c === undefined ? undefined : _c._hasPingExpired());
+      const discardPacket = this.flags.volatile && !isTransportWritable;
+      if (discardPacket) {
+        debug10("discard packet as the transport is not currently writable");
+      } else if (isConnected) {
+        this.notifyOutgoingListeners(packet);
+        this.packet(packet);
+      } else {
+        this.sendBuffer.push(packet);
+      }
+      this.flags = {};
+      return this;
+    }
+    _registerAckCallback(id3, ack) {
+      var _a4;
+      const timeout3 = (_a4 = this.flags.timeout) !== null && _a4 !== undefined ? _a4 : this._opts.ackTimeout;
+      if (timeout3 === undefined) {
+        this.acks[id3] = ack;
+        return;
+      }
+      const timer = this.io.setTimeoutFn(() => {
+        delete this.acks[id3];
+        for (let i2 = 0;i2 < this.sendBuffer.length; i2++) {
+          if (this.sendBuffer[i2].id === id3) {
+            debug10("removing packet with ack id %d from the buffer", id3);
+            this.sendBuffer.splice(i2, 1);
+          }
+        }
+        debug10("event with ack id %d has timed out after %d ms", id3, timeout3);
+        ack.call(this, new Error("operation has timed out"));
+      }, timeout3);
+      const fn2 = (...args2) => {
+        this.io.clearTimeoutFn(timer);
+        ack.apply(this, args2);
+      };
+      fn2.withError = true;
+      this.acks[id3] = fn2;
+    }
+    emitWithAck(ev, ...args2) {
+      return new Promise((resolve8, reject) => {
+        const fn2 = (arg1, arg2) => {
+          return arg1 ? reject(arg1) : resolve8(arg2);
+        };
+        fn2.withError = true;
+        args2.push(fn2);
+        this.emit(ev, ...args2);
+      });
+    }
+    _addToQueue(args2) {
+      let ack;
+      if (typeof args2[args2.length - 1] === "function") {
+        ack = args2.pop();
+      }
+      const packet = {
+        id: this._queueSeq++,
+        tryCount: 0,
+        pending: false,
+        args: args2,
+        flags: Object.assign({ fromQueue: true }, this.flags)
+      };
+      args2.push((err, ...responseArgs) => {
+        if (packet !== this._queue[0]) {
+          return debug10("packet [%d] already acknowledged", packet.id);
+        }
+        const hasError = err !== null;
+        if (hasError) {
+          if (packet.tryCount > this._opts.retries) {
+            debug10("packet [%d] is discarded after %d tries", packet.id, packet.tryCount);
+            this._queue.shift();
+            if (ack) {
+              ack(err);
+            }
+          }
+        } else {
+          debug10("packet [%d] was successfully sent", packet.id);
+          this._queue.shift();
+          if (ack) {
+            ack(null, ...responseArgs);
+          }
+        }
+        packet.pending = false;
+        return this._drainQueue();
+      });
+      this._queue.push(packet);
+      this._drainQueue();
+    }
+    _drainQueue(force = false) {
+      debug10("draining queue");
+      if (!this.connected || this._queue.length === 0) {
+        return;
+      }
+      const packet = this._queue[0];
+      if (packet.pending && !force) {
+        debug10("packet [%d] has already been sent and is waiting for an ack", packet.id);
+        return;
+      }
+      packet.pending = true;
+      packet.tryCount++;
+      debug10("sending packet [%d] (try n°%d)", packet.id, packet.tryCount);
+      this.flags = packet.flags;
+      this.emit.apply(this, packet.args);
+    }
+    packet(packet) {
+      packet.nsp = this.nsp;
+      this.io._packet(packet);
+    }
+    onopen() {
+      debug10("transport is open - connecting");
+      if (typeof this.auth == "function") {
+        this.auth((data) => {
+          this._sendConnectPacket(data);
+        });
+      } else {
+        this._sendConnectPacket(this.auth);
+      }
+    }
+    _sendConnectPacket(data) {
+      this.packet({
+        type: PacketType.CONNECT,
+        data: this._pid ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data) : data
+      });
+    }
+    onerror(err) {
+      if (!this.connected) {
+        this.emitReserved("connect_error", err);
+      }
+    }
+    onclose(reason, description) {
+      debug10("close (%s)", reason);
+      this.connected = false;
+      delete this.id;
+      this.emitReserved("disconnect", reason, description);
+      this._clearAcks();
+    }
+    _clearAcks() {
+      Object.keys(this.acks).forEach((id3) => {
+        const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id3);
+        if (!isBuffered) {
+          const ack = this.acks[id3];
+          delete this.acks[id3];
+          if (ack.withError) {
+            ack.call(this, new Error("socket has been disconnected"));
+          }
+        }
+      });
+    }
+    onpacket(packet) {
+      const sameNamespace = packet.nsp === this.nsp;
+      if (!sameNamespace)
+        return;
+      switch (packet.type) {
+        case PacketType.CONNECT:
+          if (packet.data && packet.data.sid) {
+            this.onconnect(packet.data.sid, packet.data.pid);
+          } else {
+            this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+          }
+          break;
+        case PacketType.EVENT:
+        case PacketType.BINARY_EVENT:
+          this.onevent(packet);
+          break;
+        case PacketType.ACK:
+        case PacketType.BINARY_ACK:
+          this.onack(packet);
+          break;
+        case PacketType.DISCONNECT:
+          this.ondisconnect();
+          break;
+        case PacketType.CONNECT_ERROR:
+          this.destroy();
+          const err = new Error(packet.data.message);
+          err.data = packet.data.data;
+          this.emitReserved("connect_error", err);
+          break;
+      }
+    }
+    onevent(packet) {
+      const args2 = packet.data || [];
+      debug10("emitting event %j", args2);
+      if (packet.id != null) {
+        debug10("attaching ack callback to event");
+        args2.push(this.ack(packet.id));
+      }
+      if (this.connected) {
+        this.emitEvent(args2);
+      } else {
+        this.receiveBuffer.push(Object.freeze(args2));
+      }
+    }
+    emitEvent(args2) {
+      if (this._anyListeners && this._anyListeners.length) {
+        const listeners = this._anyListeners.slice();
+        for (const listener of listeners) {
+          listener.apply(this, args2);
+        }
+      }
+      super.emit.apply(this, args2);
+      if (this._pid && args2.length && typeof args2[args2.length - 1] === "string") {
+        this._lastOffset = args2[args2.length - 1];
+      }
+    }
+    ack(id3) {
+      const self2 = this;
+      let sent = false;
+      return function(...args2) {
+        if (sent)
+          return;
+        sent = true;
+        debug10("sending ack %j", args2);
+        self2.packet({
+          type: PacketType.ACK,
+          id: id3,
+          data: args2
+        });
+      };
+    }
+    onack(packet) {
+      const ack = this.acks[packet.id];
+      if (typeof ack !== "function") {
+        debug10("bad ack %s", packet.id);
+        return;
+      }
+      delete this.acks[packet.id];
+      debug10("calling ack %s with %j", packet.id, packet.data);
+      if (ack.withError) {
+        packet.data.unshift(null);
+      }
+      ack.apply(this, packet.data);
+    }
+    onconnect(id3, pid) {
+      debug10("socket connected with id %s", id3);
+      this.id = id3;
+      this.recovered = pid && this._pid === pid;
+      this._pid = pid;
+      this.connected = true;
+      this.emitBuffered();
+      this._drainQueue(true);
+      this.emitReserved("connect");
+    }
+    emitBuffered() {
+      this.receiveBuffer.forEach((args2) => this.emitEvent(args2));
+      this.receiveBuffer = [];
+      this.sendBuffer.forEach((packet) => {
+        this.notifyOutgoingListeners(packet);
+        this.packet(packet);
+      });
+      this.sendBuffer = [];
+    }
+    ondisconnect() {
+      debug10("server disconnect (%s)", this.nsp);
+      this.destroy();
+      this.onclose("io server disconnect");
+    }
+    destroy() {
+      if (this.subs) {
+        this.subs.forEach((subDestroy) => subDestroy());
+        this.subs = undefined;
+      }
+      this.io["_destroy"](this);
+    }
+    disconnect() {
+      if (this.connected) {
+        debug10("performing disconnect (%s)", this.nsp);
+        this.packet({ type: PacketType.DISCONNECT });
+      }
+      this.destroy();
+      if (this.connected) {
+        this.onclose("io client disconnect");
+      }
+      return this;
+    }
+    close() {
+      return this.disconnect();
+    }
+    compress(compress) {
+      this.flags.compress = compress;
+      return this;
+    }
+    get volatile() {
+      this.flags.volatile = true;
+      return this;
+    }
+    timeout(timeout3) {
+      this.flags.timeout = timeout3;
+      return this;
+    }
+    onAny(listener) {
+      this._anyListeners = this._anyListeners || [];
+      this._anyListeners.push(listener);
+      return this;
+    }
+    prependAny(listener) {
+      this._anyListeners = this._anyListeners || [];
+      this._anyListeners.unshift(listener);
+      return this;
+    }
+    offAny(listener) {
+      if (!this._anyListeners) {
+        return this;
+      }
+      if (listener) {
+        const listeners = this._anyListeners;
+        for (let i2 = 0;i2 < listeners.length; i2++) {
+          if (listener === listeners[i2]) {
+            listeners.splice(i2, 1);
+            return this;
+          }
+        }
+      } else {
+        this._anyListeners = [];
+      }
+      return this;
+    }
+    listenersAny() {
+      return this._anyListeners || [];
+    }
+    onAnyOutgoing(listener) {
+      this._anyOutgoingListeners = this._anyOutgoingListeners || [];
+      this._anyOutgoingListeners.push(listener);
+      return this;
+    }
+    prependAnyOutgoing(listener) {
+      this._anyOutgoingListeners = this._anyOutgoingListeners || [];
+      this._anyOutgoingListeners.unshift(listener);
+      return this;
+    }
+    offAnyOutgoing(listener) {
+      if (!this._anyOutgoingListeners) {
+        return this;
+      }
+      if (listener) {
+        const listeners = this._anyOutgoingListeners;
+        for (let i2 = 0;i2 < listeners.length; i2++) {
+          if (listener === listeners[i2]) {
+            listeners.splice(i2, 1);
+            return this;
+          }
+        }
+      } else {
+        this._anyOutgoingListeners = [];
+      }
+      return this;
+    }
+    listenersAnyOutgoing() {
+      return this._anyOutgoingListeners || [];
+    }
+    notifyOutgoingListeners(packet) {
+      if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+        const listeners = this._anyOutgoingListeners.slice();
+        for (const listener of listeners) {
+          listener.apply(this, packet.data);
+        }
+      }
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/socket.io-client@4.8.3/node_modules/socket.io-client/build/esm-debug/contrib/backo2.js
+function Backoff(opts) {
+  opts = opts || {};
+  this.ms = opts.min || 100;
+  this.max = opts.max || 1e4;
+  this.factor = opts.factor || 2;
+  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
+  this.attempts = 0;
+}
+var init_backo2 = __esm(() => {
+  Backoff.prototype.duration = function() {
+    var ms = this.ms * Math.pow(this.factor, this.attempts++);
+    if (this.jitter) {
+      var rand = Math.random();
+      var deviation = Math.floor(rand * this.jitter * ms);
+      ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
+    }
+    return Math.min(ms, this.max) | 0;
+  };
+  Backoff.prototype.reset = function() {
+    this.attempts = 0;
+  };
+  Backoff.prototype.setMin = function(min4) {
+    this.ms = min4;
+  };
+  Backoff.prototype.setMax = function(max6) {
+    this.max = max6;
+  };
+  Backoff.prototype.setJitter = function(jitter) {
+    this.jitter = jitter;
+  };
+});
+
+// ../../node_modules/.pnpm/socket.io-client@4.8.3/node_modules/socket.io-client/build/esm-debug/manager.js
+var import_component_emitter6, import_debug11, debug11, Manager;
+var init_manager2 = __esm(() => {
+  init_esm_debug();
+  init_socket2();
+  init_esm_debug2();
+  init_backo2();
+  import_component_emitter6 = __toESM(require_cjs2(), 1);
+  import_debug11 = __toESM(require_src2(), 1);
+  debug11 = import_debug11.default("socket.io-client:manager");
+  Manager = class Manager extends import_component_emitter6.Emitter {
+    constructor(uri, opts) {
+      var _a4;
+      super();
+      this.nsps = {};
+      this.subs = [];
+      if (uri && typeof uri === "object") {
+        opts = uri;
+        uri = undefined;
+      }
+      opts = opts || {};
+      opts.path = opts.path || "/socket.io";
+      this.opts = opts;
+      installTimerFunctions(this, opts);
+      this.reconnection(opts.reconnection !== false);
+      this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
+      this.reconnectionDelay(opts.reconnectionDelay || 1000);
+      this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
+      this.randomizationFactor((_a4 = opts.randomizationFactor) !== null && _a4 !== undefined ? _a4 : 0.5);
+      this.backoff = new Backoff({
+        min: this.reconnectionDelay(),
+        max: this.reconnectionDelayMax(),
+        jitter: this.randomizationFactor()
+      });
+      this.timeout(opts.timeout == null ? 20000 : opts.timeout);
+      this._readyState = "closed";
+      this.uri = uri;
+      const _parser = opts.parser || exports_esm_debug;
+      this.encoder = new _parser.Encoder;
+      this.decoder = new _parser.Decoder;
+      this._autoConnect = opts.autoConnect !== false;
+      if (this._autoConnect)
+        this.open();
+    }
+    reconnection(v3) {
+      if (!arguments.length)
+        return this._reconnection;
+      this._reconnection = !!v3;
+      if (!v3) {
+        this.skipReconnect = true;
+      }
+      return this;
+    }
+    reconnectionAttempts(v3) {
+      if (v3 === undefined)
+        return this._reconnectionAttempts;
+      this._reconnectionAttempts = v3;
+      return this;
+    }
+    reconnectionDelay(v3) {
+      var _a4;
+      if (v3 === undefined)
+        return this._reconnectionDelay;
+      this._reconnectionDelay = v3;
+      (_a4 = this.backoff) === null || _a4 === undefined || _a4.setMin(v3);
+      return this;
+    }
+    randomizationFactor(v3) {
+      var _a4;
+      if (v3 === undefined)
+        return this._randomizationFactor;
+      this._randomizationFactor = v3;
+      (_a4 = this.backoff) === null || _a4 === undefined || _a4.setJitter(v3);
+      return this;
+    }
+    reconnectionDelayMax(v3) {
+      var _a4;
+      if (v3 === undefined)
+        return this._reconnectionDelayMax;
+      this._reconnectionDelayMax = v3;
+      (_a4 = this.backoff) === null || _a4 === undefined || _a4.setMax(v3);
+      return this;
+    }
+    timeout(v3) {
+      if (!arguments.length)
+        return this._timeout;
+      this._timeout = v3;
+      return this;
+    }
+    maybeReconnectOnOpen() {
+      if (!this._reconnecting && this._reconnection && this.backoff.attempts === 0) {
+        this.reconnect();
+      }
+    }
+    open(fn2) {
+      debug11("readyState %s", this._readyState);
+      if (~this._readyState.indexOf("open"))
+        return this;
+      debug11("opening %s", this.uri);
+      this.engine = new Socket2(this.uri, this.opts);
+      const socket = this.engine;
+      const self2 = this;
+      this._readyState = "opening";
+      this.skipReconnect = false;
+      const openSubDestroy = on(socket, "open", function() {
+        self2.onopen();
+        fn2 && fn2();
+      });
+      const onError3 = (err) => {
+        debug11("error");
+        this.cleanup();
+        this._readyState = "closed";
+        this.emitReserved("error", err);
+        if (fn2) {
+          fn2(err);
+        } else {
+          this.maybeReconnectOnOpen();
+        }
+      };
+      const errorSub = on(socket, "error", onError3);
+      if (this._timeout !== false) {
+        const timeout3 = this._timeout;
+        debug11("connect attempt will timeout after %d", timeout3);
+        const timer = this.setTimeoutFn(() => {
+          debug11("connect attempt timed out after %d", timeout3);
+          openSubDestroy();
+          onError3(new Error("timeout"));
+          socket.close();
+        }, timeout3);
+        if (this.opts.autoUnref) {
+          timer.unref();
+        }
+        this.subs.push(() => {
+          this.clearTimeoutFn(timer);
+        });
+      }
+      this.subs.push(openSubDestroy);
+      this.subs.push(errorSub);
+      return this;
+    }
+    connect(fn2) {
+      return this.open(fn2);
+    }
+    onopen() {
+      debug11("open");
+      this.cleanup();
+      this._readyState = "open";
+      this.emitReserved("open");
+      const socket = this.engine;
+      this.subs.push(on(socket, "ping", this.onping.bind(this)), on(socket, "data", this.ondata.bind(this)), on(socket, "error", this.onerror.bind(this)), on(socket, "close", this.onclose.bind(this)), on(this.decoder, "decoded", this.ondecoded.bind(this)));
+    }
+    onping() {
+      this.emitReserved("ping");
+    }
+    ondata(data) {
+      try {
+        this.decoder.add(data);
+      } catch (e) {
+        this.onclose("parse error", e);
+      }
+    }
+    ondecoded(packet) {
+      nextTick(() => {
+        this.emitReserved("packet", packet);
+      }, this.setTimeoutFn);
+    }
+    onerror(err) {
+      debug11("error", err);
+      this.emitReserved("error", err);
+    }
+    socket(nsp, opts) {
+      let socket = this.nsps[nsp];
+      if (!socket) {
+        socket = new Socket3(this, nsp, opts);
+        this.nsps[nsp] = socket;
+      } else if (this._autoConnect && !socket.active) {
+        socket.connect();
+      }
+      return socket;
+    }
+    _destroy(socket) {
+      const nsps = Object.keys(this.nsps);
+      for (const nsp of nsps) {
+        const socket2 = this.nsps[nsp];
+        if (socket2.active) {
+          debug11("socket %s is still active, skipping close", nsp);
+          return;
+        }
+      }
+      this._close();
+    }
+    _packet(packet) {
+      debug11("writing packet %j", packet);
+      const encodedPackets = this.encoder.encode(packet);
+      for (let i2 = 0;i2 < encodedPackets.length; i2++) {
+        this.engine.write(encodedPackets[i2], packet.options);
+      }
+    }
+    cleanup() {
+      debug11("cleanup");
+      this.subs.forEach((subDestroy) => subDestroy());
+      this.subs.length = 0;
+      this.decoder.destroy();
+    }
+    _close() {
+      debug11("disconnect");
+      this.skipReconnect = true;
+      this._reconnecting = false;
+      this.onclose("forced close");
+    }
+    disconnect() {
+      return this._close();
+    }
+    onclose(reason, description) {
+      var _a4;
+      debug11("closed due to %s", reason);
+      this.cleanup();
+      (_a4 = this.engine) === null || _a4 === undefined || _a4.close();
+      this.backoff.reset();
+      this._readyState = "closed";
+      this.emitReserved("close", reason, description);
+      if (this._reconnection && !this.skipReconnect) {
+        this.reconnect();
+      }
+    }
+    reconnect() {
+      if (this._reconnecting || this.skipReconnect)
+        return this;
+      const self2 = this;
+      if (this.backoff.attempts >= this._reconnectionAttempts) {
+        debug11("reconnect failed");
+        this.backoff.reset();
+        this.emitReserved("reconnect_failed");
+        this._reconnecting = false;
+      } else {
+        const delay3 = this.backoff.duration();
+        debug11("will wait %dms before reconnect attempt", delay3);
+        this._reconnecting = true;
+        const timer = this.setTimeoutFn(() => {
+          if (self2.skipReconnect)
+            return;
+          debug11("attempting reconnect");
+          this.emitReserved("reconnect_attempt", self2.backoff.attempts);
+          if (self2.skipReconnect)
+            return;
+          self2.open((err) => {
+            if (err) {
+              debug11("reconnect attempt error");
+              self2._reconnecting = false;
+              self2.reconnect();
+              this.emitReserved("reconnect_error", err);
+            } else {
+              debug11("reconnect success");
+              self2.onreconnect();
+            }
+          });
+        }, delay3);
+        if (this.opts.autoUnref) {
+          timer.unref();
+        }
+        this.subs.push(() => {
+          this.clearTimeoutFn(timer);
+        });
+      }
+    }
+    onreconnect() {
+      const attempt = this.backoff.attempts;
+      this._reconnecting = false;
+      this.backoff.reset();
+      this.emitReserved("reconnect", attempt);
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/socket.io-client@4.8.3/node_modules/socket.io-client/build/esm-debug/index.js
+function lookup2(uri, opts) {
+  if (typeof uri === "object") {
+    opts = uri;
+    uri = undefined;
+  }
+  opts = opts || {};
+  const parsed = url3(uri, opts.path || "/socket.io");
+  const source = parsed.source;
+  const id3 = parsed.id;
+  const path8 = parsed.path;
+  const sameNamespace = cache[id3] && path8 in cache[id3]["nsps"];
+  const newConnection = opts.forceNew || opts["force new connection"] || opts.multiplex === false || sameNamespace;
+  let io2;
+  if (newConnection) {
+    debug12("ignoring socket cache for %s", source);
+    io2 = new Manager(source, opts);
+  } else {
+    if (!cache[id3]) {
+      debug12("new io instance for %s", source);
+      cache[id3] = new Manager(source, opts);
+    }
+    io2 = cache[id3];
+  }
+  if (parsed.query && !opts.query) {
+    opts.query = parsed.queryKey;
+  }
+  return io2.socket(parsed.path, opts);
+}
+var import_debug12, debug12, cache;
+var init_esm_debug3 = __esm(() => {
+  init_url();
+  init_manager2();
+  init_socket2();
+  init_esm_debug2();
+  init_esm_debug();
+  import_debug12 = __toESM(require_src2(), 1);
+  debug12 = import_debug12.default("socket.io-client");
+  cache = {};
+  Object.assign(lookup2, {
+    Manager,
+    Socket: Socket3,
+    io: lookup2,
+    connect: lookup2
+  });
+});
+
+// src/daemon/local-web/client/lib/socket.ts
+async function ensureConnected(s) {
+  if (!s.connected) {
+    await new Promise((resolve8, reject) => {
+      const onConnect = () => {
+        cleanup();
+        resolve8();
+      };
+      const onError3 = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const cleanup = () => {
+        s.off("connect", onConnect);
+        s.off("connect_error", onError3);
+      };
+      s.on("connect", onConnect);
+      s.on("connect_error", onError3);
+      s.connect();
+    });
+  }
+}
+async function ingestChatroomEvent(event, port) {
+  if (!daemonSocket) {
+    daemonSocket = lookup2(`http://127.0.0.1:${port}`, { transports: ["websocket"], autoConnect: true });
+  }
+  const s = daemonSocket;
+  await ensureConnected(s);
+  const response = await s.emitWithAck("eventStream.ingest", event);
+  if (!response.ok) {
+    throw new Error(response.error?.message ?? "Failed to ingest chatroom event");
+  }
+}
+var daemonSocket = null;
+var init_socket3 = __esm(() => {
+  init_esm_debug3();
+});
+
+// src/daemon/entry/start-daemon.ts
+async function startDaemon() {
+  let resolveBoundPort;
+  const localWebPortReady = new Promise((resolve8) => {
+    resolveBoundPort = resolve8;
+  });
+  const logStreamHub = createLogStreamHub();
+  const logServer = createLogServer(resolveLogsDbPath(), {
+    onWrite: (entry) => logStreamHub.publish(entry)
+  });
+  let init2;
+  try {
+    init2 = await initDaemon({
+      logSink: logServer,
+      logEvent: async (event) => {
+        const port = await localWebPortReady;
+        return ingestChatroomEvent(event, port);
+      }
+    });
   } catch (error51) {
     logServer.close();
     throw error51;
@@ -128454,6 +131862,7 @@ async function startDaemon() {
     backend: init2.backend,
     sessionId: init2.sessionId
   });
+  resolveBoundPort(localWeb.port);
   const subscribers = startAllSubscribers({
     wsClient: wsClient2,
     sessionId: asConvexSessionId(init2.sessionId),
@@ -128490,6 +131899,7 @@ var init_start_daemon = __esm(() => {
   init_persistence();
   init_log_repository();
   init_create_local_web_server();
+  init_socket3();
 });
 
 // src/commands/machine/daemon-start/index.ts
@@ -129282,12 +132692,12 @@ handoffCommandGroup.command("view-template").description("Print the handoff mess
 });
 handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--next-role <nextRole>", "Role to hand off to").action(async (options) => {
   await maybeRequireAuth();
-  const { decode: decode5 } = await Promise.resolve().then(() => exports_decode);
+  const { decode: decode6 } = await Promise.resolve().then(() => exports_decode);
   const stdinContent = await readStdin();
   let message;
   try {
     const { HANDOFF_STDIN_DELIMITER: HANDOFF_STDIN_DELIMITER2, validateStdinHeredocBody: validateStdinHeredocBody2 } = await Promise.resolve().then(() => (init_stdin_heredoc(), exports_stdin_heredoc));
-    const result = decode5(stdinContent, { singleParam: "message" });
+    const result = decode6(stdinContent, { singleParam: "message" });
     message = result.message;
     validateStdinHeredocBody2(message, HANDOFF_STDIN_DELIMITER2);
   } catch (err) {
@@ -129308,12 +132718,12 @@ handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").
 var agenticQueryCommand = program2.command("agentic-query").description("Agentic search/ask query commands");
 agenticQueryCommand.command("complete").description("Submit the structured agentic query result markdown").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--query-id <id>", "Agentic query identifier").action(async (options) => {
   await maybeRequireAuth();
-  const { decode: decode5 } = await Promise.resolve().then(() => exports_decode);
+  const { decode: decode6 } = await Promise.resolve().then(() => exports_decode);
   const stdinContent = await readStdin();
   let result;
   try {
     const { AGENTIC_QUERY_STDIN_DELIMITER: AGENTIC_QUERY_STDIN_DELIMITER2, validateStdinHeredocBody: validateStdinHeredocBody2 } = await Promise.resolve().then(() => (init_stdin_heredoc(), exports_stdin_heredoc));
-    const decoded = decode5(stdinContent, { singleParam: "result" });
+    const decoded = decode6(stdinContent, { singleParam: "result" });
     let body = decoded.result;
     body = body.replace(/^(---RESULT---\s*)+/i, "").trim();
     validateStdinHeredocBody2(body, AGENTIC_QUERY_STDIN_DELIMITER2);
@@ -129335,12 +132745,12 @@ agenticQueryCommand.command("complete").description("Submit the structured agent
 var enhancerCommand = program2.command("enhancer").description("Handoff enhancer commands");
 enhancerCommand.command("complete").description("Submit the enhanced handoff markdown").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--job-id <id>", "Enhancer job identifier").action(async (options) => {
   await maybeRequireAuth();
-  const { decode: decode5 } = await Promise.resolve().then(() => exports_decode);
+  const { decode: decode6 } = await Promise.resolve().then(() => exports_decode);
   const stdinContent = await readStdin();
   let body;
   try {
     const { ENHANCER_STDIN_DELIMITER: ENHANCER_STDIN_DELIMITER2, HANDOFF_MESSAGE_MARKER: HANDOFF_MESSAGE_MARKER2, validateStdinHeredocBody: validateStdinHeredocBody2 } = await Promise.resolve().then(() => (init_stdin_heredoc(), exports_stdin_heredoc));
-    const decoded = decode5(stdinContent, { singleParam: "result" });
+    const decoded = decode6(stdinContent, { singleParam: "result" });
     body = decoded.result;
     body = body.replace(new RegExp(`^(${HANDOFF_MESSAGE_MARKER2}\\s*)+`, "i"), "").trim();
     validateStdinHeredocBody2(body, ENHANCER_STDIN_DELIMITER2);
@@ -129707,4 +133117,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=7848C1A022D1F30A64756E2164756E21
+//# debugId=2985C1A25A95ABE964756E2164756E21