@mindstudio-ai/local-model-tunnel 0.5.21 → 0.5.23

package/dist/{chunk-YTHFWJU6.js → chunk-ALEWMAQ4.js}

@@ -22,19 +22,29 @@ import {
   syncSchema,
   watchConfigFile,
   watchTableFiles
-} from "./chunk-VJTZSOKC.js";
+} from "./chunk-HZZVPY7J.js";
+
+// src/dev/ipc.ts
+function emitEvent(event, data) {
+  process.stdout.write(JSON.stringify({ event, ...data }) + "\n");
+}
+function emitResponse(action, requestId, status, data) {
+  process.stdout.write(
+    JSON.stringify({ event: action, requestId, status, ...data }) + "\n"
+  );
+}
 
 // src/dev/session-events.ts
-function subscribeDevEvents(emit2, shutdown) {
+function subscribeDevEvents(shutdown) {
   const unsubs = [];
   unsubs.push(
     devRequestEvents.onStart((event) => {
-      emit2("method-started", { id: event.id, method: event.method });
+      emitEvent("platform-method-started", { id: event.id, method: event.method });
     })
   );
   unsubs.push(
     devRequestEvents.onComplete((event) => {
-      emit2("method-completed", {
+      emitEvent("platform-method-completed", {
         id: event.id,
         success: event.success,
         duration: event.duration,
@@ -44,248 +54,211 @@ function subscribeDevEvents(emit2, shutdown) {
   );
   unsubs.push(
     devRequestEvents.onConnectionWarning((message) => {
-      emit2("connection-lost", { message });
+      emitEvent("connection-lost", { message });
     })
   );
   unsubs.push(
     devRequestEvents.onConnectionRestored(() => {
-      emit2("connection-restored");
+      emitEvent("connection-restored");
     })
   );
   unsubs.push(
     devRequestEvents.onSessionExpired(() => {
-      emit2("session-expired");
+      emitEvent("session-expired");
       shutdown().then(() => process.exit(1));
     })
   );
   unsubs.push(
     devRequestEvents.onAuthRefreshStart((url) => {
-      emit2("auth-refresh-start", { url });
+      emitEvent("auth-refresh-start", { url });
     })
   );
   unsubs.push(
     devRequestEvents.onAuthRefreshSuccess(() => {
-      emit2("auth-refresh-success");
+      emitEvent("auth-refresh-success");
     })
   );
   unsubs.push(
     devRequestEvents.onAuthRefreshFailed(() => {
-      emit2("auth-refresh-failed");
-    })
-  );
-  unsubs.push(
-    devRequestEvents.onImpersonate((event) => {
-      emit2("impersonation-changed", { roles: event.roles });
-    })
-  );
-  unsubs.push(
-    devRequestEvents.onScenarioStart((event) => {
-      emit2("scenario-started", { id: event.id, name: event.name });
-    })
-  );
-  unsubs.push(
-    devRequestEvents.onScenarioComplete((event) => {
-      emit2("scenario-completed", {
-        id: event.id,
-        success: event.success,
-        duration: event.duration,
-        roles: event.roles,
-        ...event.error ? { error: event.error } : {}
-      });
+      emitEvent("auth-refresh-failed");
     })
   );
   return unsubs;
 }
 
 // src/dev/stdin-commands/run-scenario.ts
-async function handleRunScenario(state, cwd, cmd, emit2) {
-  if (!state.runner) {
-    emit2("command-error", { message: "No active session" });
-    return;
-  }
-  const freshConfig = detectAppConfig(cwd) ?? state.appConfig;
+async function handleRunScenario(ctx, cmd) {
+  if (!ctx.state.runner) throw new Error("No active session");
+  const freshConfig = detectAppConfig(ctx.cwd) ?? ctx.state.appConfig;
   const scenario = freshConfig?.scenarios.find((s) => s.id === cmd.scenarioId);
-  if (!scenario) {
-    emit2("command-error", { message: `Unknown scenario: ${cmd.scenarioId}` });
-    return;
-  }
-  await state.runner.runScenario(scenario);
+  if (!scenario) throw new Error(`Unknown scenario: ${cmd.scenarioId}`);
+  const scenarioName = scenario.name ?? scenario.export;
+  ctx.started({ scenarioId: scenario.id, name: scenarioName });
+  const result = await ctx.state.runner.runScenario(scenario);
+  return {
+    success: result.success,
+    scenarioId: scenario.id,
+    name: scenarioName,
+    ...result.error ? { error: result.error } : {}
+  };
 }
 
 // src/dev/stdin-commands/run-method.ts
-async function handleRunMethod(state, cwd, cmd, emit2) {
-  if (!state.runner) {
-    emit2("command-error", { message: "No active session" });
-    return;
-  }
+async function handleRunMethod(ctx, cmd) {
+  if (!ctx.state.runner) throw new Error("No active session");
   const methodName = cmd.method;
-  if (!methodName) {
-    emit2("command-error", { message: 'run-method requires "method" (export name or ID)' });
-    return;
-  }
-  const freshConfig = detectAppConfig(cwd) ?? state.appConfig;
+  if (!methodName) throw new Error('run-method requires "method" (export name or ID)');
+  const freshConfig = detectAppConfig(ctx.cwd) ?? ctx.state.appConfig;
   const method = freshConfig?.methods.find((m) => m.export === methodName) ?? freshConfig?.methods.find((m) => m.id === methodName);
-  if (!method) {
-    emit2("command-error", { message: `Unknown method: ${methodName}` });
-    return;
-  }
-  emit2("method-run-started", { method: method.export });
-  const result = await state.runner.runMethod({
+  if (!method) throw new Error(`Unknown method: ${methodName}`);
+  ctx.started({ method: method.export });
+  const result = await ctx.state.runner.runMethod({
     methodExport: method.export,
     methodPath: method.path,
     input: cmd.input ?? {}
   });
-  emit2("method-run-completed", {
-    method: method.export,
+  return {
     success: result.success,
+    method: method.export,
     output: result.output ?? null,
     error: result.error ?? null,
     stdout: result.stdout ?? [],
     duration: result.duration
-  });
+  };
 }
 
 // src/dev/stdin-commands/impersonate.ts
-async function handleImpersonate(state, cmd, emit2) {
-  if (!state.runner) {
-    emit2("command-error", { message: "No active session" });
-    return;
-  }
+async function handleImpersonate(ctx, cmd) {
+  if (!ctx.state.runner) throw new Error("No active session");
   const roles = cmd.roles;
-  if (!Array.isArray(roles)) {
-    emit2("command-error", { message: "impersonate requires roles array" });
-    return;
-  }
-  await state.runner.setImpersonation(roles);
+  if (!Array.isArray(roles)) throw new Error("impersonate requires roles array");
+  await ctx.state.runner.setImpersonation(roles);
+  return { roles };
 }
-async function handleClearImpersonation(state, emit2) {
-  if (!state.runner) {
-    emit2("command-error", { message: "No active session" });
-    return;
-  }
-  await state.runner.clearImpersonation();
+async function handleClearImpersonation(ctx) {
+  if (!ctx.state.runner) throw new Error("No active session");
+  await ctx.state.runner.clearImpersonation();
+  return { roles: null };
 }
 
 // src/dev/stdin-commands/browser.ts
-async function handleBrowser(state, cmd, emit2) {
-  if (!state.proxy) {
-    emit2("command-error", { message: "No active proxy \u2014 browser commands require a web interface" });
-    return;
-  }
+async function handleBrowser(ctx, cmd) {
+  if (!ctx.state.proxy) throw new Error("No active proxy \u2014 browser commands require a web interface");
   const steps = cmd.steps;
   if (!Array.isArray(steps) || steps.length === 0) {
-    emit2("command-error", { message: 'browser action requires a non-empty "steps" array' });
-    return;
+    throw new Error('browser action requires a non-empty "steps" array');
   }
-  try {
-    const result = await state.proxy.dispatchBrowserCommand(steps);
-    emit2("browser-completed", {
-      steps: result.steps,
-      snapshot: result.snapshot,
-      logs: result.logs,
-      duration: result.duration
-    });
-  } catch (err) {
-    emit2("command-error", {
-      message: err instanceof Error ? err.message : "Browser command failed"
-    });
+  const preparedSteps = await injectScreenshotUploads(ctx, steps);
+  const result = await ctx.state.proxy.dispatchBrowserCommand(preparedSteps);
+  const resultSteps = result.steps ?? [];
+  for (const step of resultSteps) {
+    const stepResult = step.result;
+    if (stepResult?.uploaded && stepResult?._publicUrl) {
+      stepResult.url = stepResult._publicUrl;
+      delete stepResult.uploaded;
+      delete stepResult._publicUrl;
+      delete stepResult.image;
+    }
   }
+  return {
+    steps: resultSteps,
+    snapshot: result.snapshot,
+    logs: result.logs,
+    duration: result.duration
+  };
+}
+async function injectScreenshotUploads(ctx, steps) {
+  const session = ctx.state.runner?.getSession();
+  const appId = ctx.state.appConfig?.appId;
+  if (!session || !appId) return steps;
+  const prepared = [];
+  for (const step of steps) {
+    if (step.command === "screenshot") {
+      try {
+        const { uploadUrl, uploadFields, publicUrl } = await getUploadUrl(
+          appId,
+          session.sessionId,
+          "jpg",
+          "image/jpeg"
+        );
+        prepared.push({ ...step, uploadUrl, uploadFields, _publicUrl: publicUrl });
+      } catch {
+        prepared.push(step);
+      }
+    } else {
+      prepared.push(step);
+    }
+  }
+  return prepared;
 }
 
 // src/dev/stdin-commands/screenshot.ts
-async function handleScreenshot(state, emit2) {
-  const fail = (message) => {
-    emit2("screenshot-completed", {
-      url: "",
-      width: 0,
-      height: 0,
-      duration: 0,
-      error: message
-    });
-  };
-  if (!state.proxy) {
-    fail("No active proxy");
-    return;
-  }
-  if (!state.proxy.isBrowserConnected()) {
-    fail("No browser connected, please refresh the MindStudio preview");
-    return;
+async function handleScreenshot(ctx, cmd) {
+  if (!ctx.state.proxy) throw new Error("No active proxy");
+  if (!ctx.state.proxy.isBrowserConnected()) {
+    throw new Error("No browser connected, please refresh the MindStudio preview");
   }
-  if (!state.runner?.getSession() || !state.appConfig?.appId) {
-    fail("No active session");
-    return;
+  if (!ctx.state.runner?.getSession() || !ctx.state.appConfig?.appId) {
+    throw new Error("No active session");
   }
-  try {
-    const startTime = Date.now();
-    const result = await state.proxy.dispatchBrowserCommand([{ command: "screenshot" }]);
-    const stepResult = result.steps?.[0]?.result;
-    if (!stepResult?.image) {
-      fail("Screenshot capture returned no image data");
-      return;
-    }
-    const session = state.runner.getSession();
-    const { uploadUrl, uploadFields, publicUrl } = await getUploadUrl(
-      state.appConfig.appId,
-      session.sessionId,
-      "jpg",
-      "image/jpeg"
-    );
-    const imageBuffer = Buffer.from(stepResult.image, "base64");
-    const form = new FormData();
-    for (const [key, value] of Object.entries(uploadFields)) {
-      form.append(key, value);
-    }
-    form.append("file", new Blob([imageBuffer], { type: "image/jpeg" }), "screenshot.jpg");
-    const uploadResult = await fetch(uploadUrl, { method: "POST", body: form });
-    if (!uploadResult.ok) {
-      fail(`S3 upload failed: ${uploadResult.status}`);
-      return;
-    }
-    emit2("screenshot-completed", {
-      url: publicUrl,
-      width: stepResult.width,
-      height: stepResult.height,
-      duration: Date.now() - startTime
-    });
-  } catch (err) {
-    fail(err instanceof Error ? err.message : "Screenshot failed");
+  const startTime = Date.now();
+  const session = ctx.state.runner.getSession();
+  const { uploadUrl, uploadFields, publicUrl } = await getUploadUrl(
+    ctx.state.appConfig.appId,
+    session.sessionId,
+    "jpg",
+    "image/jpeg"
+  );
+  const fullPage = cmd.fullPage !== false;
+  const result = await ctx.state.proxy.dispatchBrowserCommand(
+    [{ command: "screenshot", fullPage, scrollToTop: true, uploadUrl, uploadFields }],
+    12e4
+  );
+  const stepResult = result.steps?.[0]?.result;
+  if (!stepResult?.uploaded) {
+    throw new Error("Screenshot capture or upload failed");
   }
+  return {
+    url: publicUrl,
+    width: stepResult.width,
+    height: stepResult.height,
+    duration: Date.now() - startTime
+  };
 }
 
 // src/dev/stdin-commands/dev-server-restarting.ts
-async function handleDevServerRestarting(state, emit2) {
-  if (!state.proxy) {
-    emit2("command-error", { message: "No active proxy" });
-    return;
-  }
-  state.proxy.markUpstreamDown();
-  emit2("dev-server-restarting-ack", {});
+async function handleDevServerRestarting(ctx) {
+  if (!ctx.state.proxy) throw new Error("No active proxy");
+  ctx.state.proxy.markUpstreamDown();
+  return {};
 }
 
 // src/dev/stdin-commands/browser-status.ts
-function handleBrowserStatus(state, emit2) {
-  emit2("browser-status", {
-    connected: state.proxy?.isBrowserConnected() ?? false
-  });
+async function handleBrowserStatus(ctx) {
+  return { connected: ctx.state.proxy?.isBrowserConnected() ?? false };
 }
 
 // src/dev/stdin-commands/reset-browser.ts
-function handleResetBrowser(state, emit2) {
-  if (!state.proxy) {
-    emit2("command-error", { message: "No active proxy" });
-    return;
-  }
-  if (!state.proxy.isBrowserConnected()) {
-    emit2("command-error", { message: "No browser connected" });
-    return;
-  }
-  state.proxy.dispatchBrowserCommand([{ command: "reload" }]).catch(() => {
-  });
-  emit2("reset-browser-completed", {});
+async function handleResetBrowser(ctx) {
+  if (!ctx.state.proxy) throw new Error("No active proxy");
+  if (!ctx.state.proxy.isBrowserConnected()) throw new Error("No browser connected");
+  ctx.state.proxy.broadcastToClients("reload");
+  return {};
 }
 
 // src/dev/stdin-commands/index.ts
-function setupStdinCommands(state, cwd, emit2) {
+var handlers = {
+  "run-method": handleRunMethod,
+  "run-scenario": handleRunScenario,
+  "impersonate": handleImpersonate,
+  "clear-impersonation": handleClearImpersonation,
+  "browser": handleBrowser,
+  "screenshot": handleScreenshot,
+  "browser-status": handleBrowserStatus,
+  "reset-browser": handleResetBrowser,
+  "dev-server-restarting": handleDevServerRestarting
+};
+function setupStdinCommands(state, cwd) {
   if (!process.stdin.readable) return;
   let buffer = "";
   process.stdin.setEncoding("utf-8");
@@ -296,53 +269,58 @@ function setupStdinCommands(state, cwd, emit2) {
       const line = buffer.slice(0, idx).trim();
       buffer = buffer.slice(idx + 1);
       if (!line) continue;
+      let cmd;
       try {
-        const cmd = JSON.parse(line);
-        handleStdinCommand(cmd, state, cwd, emit2);
+        cmd = JSON.parse(line);
       } catch {
-        emit2("command-error", { message: `Invalid JSON on stdin: ${line.slice(0, 100)}` });
+        log.warn("Invalid JSON on stdin", { preview: line.slice(0, 100) });
+        continue;
       }
+      handleStdinCommand(cmd, state, cwd);
     }
   });
 }
-async function handleStdinCommand(cmd, state, cwd, emit2) {
-  switch (cmd.action) {
-    case "run-scenario":
-      return handleRunScenario(state, cwd, cmd, emit2);
-    case "run-method":
-      return handleRunMethod(state, cwd, cmd, emit2);
-    case "impersonate":
-      return handleImpersonate(state, cmd, emit2);
-    case "clear-impersonation":
-      return handleClearImpersonation(state, emit2);
-    case "browser":
-      return handleBrowser(state, cmd, emit2);
-    case "screenshot":
-      return handleScreenshot(state, emit2);
-    case "dev-server-restarting":
-      return handleDevServerRestarting(state, emit2);
-    case "browser-status":
-      return handleBrowserStatus(state, emit2);
-    case "reset-browser":
-      return handleResetBrowser(state, emit2);
-    default:
-      emit2("command-error", { message: `Unknown action: ${cmd.action}` });
+async function handleStdinCommand(cmd, state, cwd) {
+  const { requestId, action } = cmd;
+  if (!requestId) {
+    log.warn("Command rejected: missing requestId", { action });
+    return;
+  }
+  const handler = handlers[action];
+  if (!handler) {
+    emitResponse(action ?? "unknown", requestId, "completed", {
+      success: false,
+      error: `Unknown action: ${action}`
+    });
+    return;
+  }
+  const ctx = {
+    state,
+    cwd,
+    requestId,
+    started: (data) => emitResponse(action, requestId, "started", data)
+  };
+  try {
+    const result = await handler(ctx, cmd);
+    emitResponse(action, requestId, "completed", result);
+  } catch (err) {
+    emitResponse(action, requestId, "completed", {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
   }
 }
 
 // src/headless.ts
-function emit(event, data) {
-  process.stdout.write(JSON.stringify({ event, ...data }) + "\n");
-}
 async function startSession(cwd, opts, state, shutdown) {
   const bindAddress = opts.bindAddress ?? "127.0.0.1";
   const appConfig = detectAppConfig(cwd);
   if (!appConfig) {
-    emit("config-error", { message: "No valid mindstudio.json found in " + cwd });
+    emitEvent("config-error", { message: "No valid mindstudio.json found in " + cwd });
     return false;
   }
   if (!appConfig.appId) {
-    emit("config-error", { message: 'Missing "appId" in mindstudio.json' });
+    emitEvent("config-error", { message: 'Missing "appId" in mindstudio.json' });
     return false;
   }
   state.appConfig = appConfig;
@@ -351,7 +329,7 @@ async function startSession(cwd, opts, state, shutdown) {
     const webConfig = getWebInterfaceConfig(appConfig, cwd);
     devPort = webConfig?.devPort ?? null;
   }
-  emit("session-starting", { appId: appConfig.appId, name: appConfig.name });
+  emitEvent("session-starting", { appId: appConfig.appId, name: appConfig.name });
   try {
     const branch = detectGitBranch();
     const runner = new DevRunner(appConfig.appId, cwd, {
@@ -368,7 +346,7 @@ async function startSession(cwd, opts, state, shutdown) {
         if (tableSources.length > 0) {
           const syncResult = await syncSchema(appConfig.appId, session.sessionId, tableSources);
           session.databases = syncResult.databases;
-          emit("schema-sync-completed", {
+          emitEvent("schema-sync-completed", {
             created: syncResult.created,
             altered: syncResult.altered,
             errors: syncResult.errors
@@ -379,29 +357,32 @@ async function startSession(cwd, opts, state, shutdown) {
           });
         }
       } catch (err) {
-        emit("schema-sync-completed", {
+        emitEvent("schema-sync-completed", {
           created: [],
           altered: [],
           errors: [err instanceof Error ? err.message : "Schema sync failed"]
         });
       }
     }
-    let proxyPort = null;
     if (devPort !== null && session.clientContext) {
-      const proxy = new DevProxy(devPort, session.clientContext, bindAddress, opts.browserAgentUrl);
-      const preferred = opts.proxyPort ?? stablePort(appConfig.appId);
-      proxyPort = await proxy.start(preferred);
-      runner.setProxyUrl(`http://${bindAddress === "0.0.0.0" ? "localhost" : bindAddress}:${proxyPort}`);
-      runner.setProxy(proxy);
-      state.proxy = proxy;
+      if (state.proxy) {
+        state.proxy.updateClientContext(session.clientContext);
+      } else {
+        const proxy = new DevProxy(devPort, session.clientContext, bindAddress, opts.browserAgentUrl);
+        const preferred = opts.proxyPort ?? stablePort(appConfig.appId);
+        const proxyPort = await proxy.start(preferred);
+        state.proxy = proxy;
+        state.proxyPort = proxyPort;
+      }
+      runner.setProxyUrl(`http://${bindAddress === "0.0.0.0" ? "localhost" : bindAddress}:${state.proxyPort}`);
+      runner.setProxy(state.proxy);
     }
-    state.proxyPort = proxyPort;
-    emit("session-started", {
+    emitEvent("session-started", {
       sessionId: session.sessionId,
       releaseId: session.releaseId,
       branch: session.branch,
-      proxyPort,
-      proxyUrl: proxyPort ? `http://${bindAddress === "0.0.0.0" ? "localhost" : bindAddress}:${proxyPort}/` : null,
+      proxyPort: state.proxyPort,
+      proxyUrl: state.proxyPort ? `http://${bindAddress === "0.0.0.0" ? "localhost" : bindAddress}:${state.proxyPort}/` : null,
       webInterfaceUrl: session.webInterfaceUrl,
       roles: appConfig.roles.map((r) => ({ id: r.id, name: r.name ?? r.id, description: r.description })),
       scenarios: appConfig.scenarios.map((s) => ({
@@ -412,11 +393,11 @@ async function startSession(cwd, opts, state, shutdown) {
         roles: s.roles
       }))
     });
-    state.unsubscribers.push(...subscribeDevEvents(emit, shutdown));
+    state.unsubscribers.push(...subscribeDevEvents(shutdown));
     setupTableWatchers(cwd, state);
     return true;
   } catch (err) {
-    emit("config-error", {
+    emitEvent("config-error", {
       message: err instanceof Error ? err.message : "Failed to start session"
     });
     return false;
@@ -428,14 +409,14 @@ function setupTableWatchers(cwd, state) {
     if (!state.runner || !state.appConfig?.appId) return;
     const session = state.runner.getSession();
     if (!session) return;
-    emit("schema-sync-started");
+    emitEvent("schema-sync-started");
     log.info("Table source file changed, syncing schema");
     try {
       const tableSources = readTableSources(state.appConfig, cwd);
       if (tableSources.length > 0) {
         const result = await syncSchema(state.appConfig.appId, session.sessionId, tableSources);
         session.databases = result.databases;
-        emit("schema-sync-completed", {
+        emitEvent("schema-sync-completed", {
           created: result.created,
           altered: result.altered,
           errors: result.errors
@@ -448,18 +429,15 @@ function setupTableWatchers(cwd, state) {
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : "Schema sync failed";
-      emit("command-error", { message });
+      emitEvent("schema-sync-completed", { created: [], altered: [], errors: [message] });
       log.warn("Schema sync failed", { error: message });
     }
   });
   state.unsubscribers.push(cleanup);
 }
-async function teardownSession(state) {
+async function teardownRunner(state) {
   for (const unsub of state.unsubscribers) unsub();
   state.unsubscribers = [];
-  state.proxy?.stop();
-  state.proxy = null;
-  state.proxyPort = null;
   if (state.runner) {
     await state.runner.stop().catch(() => {
     });
@@ -468,6 +446,12 @@ async function teardownSession(state) {
   closeRequestLog();
   closeBrowserLog();
 }
+async function teardownAll(state) {
+  await teardownRunner(state);
+  state.proxy?.stop();
+  state.proxy = null;
+  state.proxyPort = null;
+}
 async function startHeadless(opts = {}) {
   initLoggerHeadless(opts.logLevel ?? "info");
   const cwd = opts.cwd ?? process.cwd();
@@ -496,10 +480,10 @@ async function startHeadless(opts = {}) {
   const shutdown = async () => {
     if (stopping) return;
     stopping = true;
-    emit("session-stopping");
+    emitEvent("session-stopping");
     cleanupConfigWatcher?.();
-    await teardownSession(state);
-    emit("session-stopped");
+    await teardownAll(state);
+    emitEvent("session-stopped");
   };
   process.on("SIGTERM", () => {
     shutdown().then(() => process.exit(0));
@@ -511,18 +495,17 @@ async function startHeadless(opts = {}) {
   if (!ok) {
     process.exit(1);
   }
-  setupStdinCommands(state, cwd, emit);
+  setupStdinCommands(state, cwd);
   cleanupConfigWatcher = watchConfigFile(cwd, async () => {
     if (stopping || restarting) return;
     restarting = true;
     try {
       log.info("mindstudio.json changed, restarting dev session");
-      emit("config-changed");
-      await teardownSession(state);
+      emitEvent("config-changed");
+      await teardownRunner(state);
       const ok2 = await startSession(cwd, opts, state, shutdown);
       if (ok2 && state.proxy) {
-        state.proxy.dispatchBrowserCommand([{ command: "reload" }]).catch(() => {
-        });
+        state.proxy.broadcastToClients("reload");
       }
     } finally {
       restarting = false;
@@ -535,4 +518,4 @@ async function startHeadless(opts = {}) {
 export {
   startHeadless
 };
-//# sourceMappingURL=chunk-YTHFWJU6.js.map
+//# sourceMappingURL=chunk-ALEWMAQ4.js.map