opendevbrowser 0.0.28 → 0.0.29

package/dist/chunk-LBPELU7L.js

@@ -0,0 +1,3649 @@
+import {
+  SCREENCAST_RETENTION_MS,
+  buildBrowserReviewResult,
+  buildLoopbackSessionRelayEndpoint,
+  classifySessionRelayEndpoint,
+  createOpenDevBrowserCore,
+  readCookiesFromSource,
+  resolveBundledProviderRuntime,
+  resolveSessionRelayRoute
+} from "./chunk-SXAGSEKZ.js";
+import {
+  loadGlobalConfig,
+  resolveConfig
+} from "./chunk-MX3NFLCE.js";
+import {
+  generateSecureToken
+} from "./chunk-ASMHEEKY.js";
+import {
+  buildMacroResolveSuccessHandoff,
+  detectSocialSearchShell,
+  isChallengeAutomationMode,
+  runInspiredesignWorkflow,
+  runProductVideoWorkflow,
+  runResearchWorkflow,
+  runShoppingWorkflow
+} from "./chunk-S6S2UP6U.js";
+import {
+  buildBlockerArtifacts,
+  classifyBlockerSignal,
+  redactSensitive
+} from "./chunk-WHQZBUNY.js";
+
+// src/cli/utils/http.ts
+var DEFAULT_HTTP_TIMEOUT_MS = 5e3;
+function isAbortError(error) {
+  if (!error || typeof error !== "object") return false;
+  return "name" in error && error.name === "AbortError";
+}
+var resolveTimeoutMs = (timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) => {
+  return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_HTTP_TIMEOUT_MS;
+};
+var createTimeoutError = (timeoutMs) => {
+  return new Error(`Request timed out after ${timeoutMs}ms`);
+};
+var createTimedSignal = (timeoutMs, upstreamSignal) => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  let removeAbortListener;
+  if (upstreamSignal) {
+    if (upstreamSignal.aborted) {
+      controller.abort(upstreamSignal.reason);
+    } else {
+      const onAbort = () => controller.abort(upstreamSignal.reason);
+      upstreamSignal.addEventListener("abort", onAbort, { once: true });
+      removeAbortListener = () => upstreamSignal.removeEventListener("abort", onAbort);
+    }
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timeoutId);
+      removeAbortListener?.();
+    }
+  };
+};
+var cancelResponseBody = (response) => {
+  try {
+    const cancelResult = response.body?.cancel?.();
+    if (cancelResult instanceof Promise) {
+      void cancelResult.catch(() => {
+      });
+    }
+  } catch {
+  }
+};
+var readResponseBodyWithTimeout = async (response, signal, timeoutMs, reader) => {
+  let bodyCancelled = false;
+  const cancelBody = () => {
+    if (bodyCancelled) {
+      return;
+    }
+    bodyCancelled = true;
+    cancelResponseBody(response);
+  };
+  if (signal.aborted) {
+    cancelBody();
+    throw createTimeoutError(timeoutMs);
+  }
+  let removeAbortListener;
+  const abortPromise = new Promise((_, reject) => {
+    const onAbort = () => {
+      cancelBody();
+      reject(createTimeoutError(timeoutMs));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+  });
+  try {
+    return await Promise.race([reader(), abortPromise]);
+  } catch (error) {
+    if (signal.aborted || isAbortError(error)) {
+      cancelBody();
+      throw createTimeoutError(timeoutMs);
+    }
+    throw error;
+  } finally {
+    removeAbortListener?.();
+  }
+};
+async function fetchWithTimeout(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
+  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
+  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
+  try {
+    return await fetch(input, { ...init, signal: timedSignal.signal });
+  } catch (error) {
+    if (isAbortError(error) || timedSignal.signal.aborted) {
+      throw createTimeoutError(resolvedTimeout);
+    }
+    throw error;
+  } finally {
+    timedSignal.dispose();
+  }
+}
+async function fetchWithTimeoutContext(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
+  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
+  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
+  try {
+    const response = await fetch(input, { ...init, signal: timedSignal.signal });
+    return {
+      response,
+      signal: timedSignal.signal,
+      timeoutMs: resolvedTimeout,
+      dispose: timedSignal.dispose
+    };
+  } catch (error) {
+    timedSignal.dispose();
+    if (isAbortError(error) || timedSignal.signal.aborted) {
+      throw createTimeoutError(resolvedTimeout);
+    }
+    throw error;
+  }
+}
+async function readResponseTextWithTimeout(response, signal, timeoutMs) {
+  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.text());
+}
+async function readResponseJsonWithTimeout(response, signal, timeoutMs) {
+  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.json());
+}
+
+// src/cli/daemon.ts
+import { createServer } from "http";
+import { createHash, timingSafeEqual } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync, unlinkSync, existsSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/daemon-commands.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/browser/session-inspector.ts
+import { randomUUID } from "crypto";
+async function inspectSession(handle, options) {
+  const [session, targets, traceRaw] = await Promise.all([
+    handle.status(options.sessionId),
+    handle.listTargets(options.sessionId, options.includeUrls ?? true),
+    handle.debugTraceSnapshot(options.sessionId, {
+      sinceConsoleSeq: options.sinceConsoleSeq,
+      sinceNetworkSeq: options.sinceNetworkSeq,
+      sinceExceptionSeq: options.sinceExceptionSeq,
+      max: options.max ?? 25,
+      requestId: options.requestId
+    })
+  ]);
+  const trace = asRecord(traceRaw);
+  const tracePage = asRecord(trace.page);
+  const traceMeta = asRecord(trace.meta);
+  const traceConsole = summarizeConsole(readChannel(trace, "console"));
+  const traceNetwork = summarizeNetwork(readChannel(trace, "network"));
+  const traceException = summarizeException(readChannel(trace, "exception"));
+  const blockerState = readBlockerState(traceMeta, session.meta);
+  const relay = options.relayStatus ? summarizeRelay(options.relayStatus) : null;
+  const healthState = deriveHealthState({
+    mode: session.mode,
+    blockerState,
+    dialogOpen: session.meta?.dialog?.open === true,
+    relay,
+    activeTargetId: targets.activeTargetId,
+    consoleErrors: traceConsole.errorCount,
+    networkFailures: traceNetwork.failureCount,
+    exceptionCount: traceException.eventCount
+  });
+  return {
+    session,
+    relay,
+    targets: {
+      activeTargetId: targets.activeTargetId,
+      count: targets.targets.length,
+      items: targets.targets
+    },
+    console: traceConsole,
+    network: traceNetwork,
+    exception: traceException,
+    proofArtifact: {
+      source: "debug_trace_snapshot",
+      requestId: getString(trace.requestId) ?? options.requestId ?? null,
+      generatedAt: getString(trace.generatedAt) ?? null,
+      blockerState,
+      ...getString(tracePage.url) || session.url ? { url: getString(tracePage.url) ?? session.url } : {},
+      ...getString(tracePage.title) || session.title ? { title: getString(tracePage.title) ?? session.title } : {}
+    },
+    healthState,
+    suggestedNextAction: deriveSuggestedNextAction({
+      mode: session.mode,
+      dialogOpen: session.meta?.dialog?.open === true,
+      blockerState,
+      relay,
+      activeTargetId: targets.activeTargetId,
+      consoleErrors: traceConsole.errorCount,
+      networkFailures: traceNetwork.failureCount,
+      exceptionCount: traceException.eventCount
+    })
+  };
+}
+async function buildCorrelatedAuditBundle(args) {
+  const requestId = args.requestId ?? randomUUID();
+  const sessionInspector = await inspectSession(args.handle, {
+    sessionId: args.browserSessionId,
+    includeUrls: args.includeUrls,
+    sinceConsoleSeq: args.sinceConsoleSeq,
+    sinceNetworkSeq: args.sinceNetworkSeq,
+    sinceExceptionSeq: args.sinceExceptionSeq,
+    max: args.max,
+    requestId,
+    relayStatus: args.relayStatus
+  });
+  return {
+    bundleId: randomUUID(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    browserSessionId: args.browserSessionId,
+    ...typeof args.targetId !== "undefined" ? { targetId: args.targetId } : {},
+    observationId: args.observation.observationId,
+    requestId: sessionInspector.proofArtifact.requestId ?? requestId,
+    ...args.challengePlan.challengeId ? { challengeId: args.challengePlan.challengeId } : {},
+    desktop: args.observation,
+    review: args.review,
+    sessionInspector,
+    challengePlan: args.challengePlan
+  };
+}
+function readChannel(trace, channelName) {
+  const channels = asRecord(trace.channels);
+  const channel = asRecord(channels[channelName]);
+  const events = asArray(channel.events);
+  return {
+    events,
+    nextSeq: getNumber(channel.nextSeq),
+    truncated: getBoolean(channel.truncated) ?? false
+  };
+}
+function summarizeException(channel) {
+  const events = channel.events.map((entry) => {
+    const record = asRecord(entry);
+    const message = [
+      getString(record.text),
+      getString(record.message),
+      getString(record.value)
+    ].find((value) => typeof value === "string" && value.trim().length > 0);
+    const url = getString(record.url) ?? getString(record.sourceURL) ?? void 0;
+    const line = getNumber(record.lineNumber) ?? getNumber(record.line) ?? void 0;
+    const column = getNumber(record.columnNumber) ?? getNumber(record.column) ?? void 0;
+    if (!message && !url && typeof line !== "number" && typeof column !== "number") {
+      return null;
+    }
+    return {
+      message: message?.trim() ?? "Unhandled exception",
+      ...url ? { url } : {},
+      ...typeof line === "number" ? { line } : {},
+      ...typeof column === "number" ? { column } : {}
+    };
+  }).filter((entry) => entry !== null);
+  return {
+    eventCount: channel.events.length,
+    nextSeq: channel.nextSeq,
+    truncated: channel.truncated,
+    latest: events.slice(-3).reverse()
+  };
+}
+function summarizeConsole(channel) {
+  const events = channel.events.map((entry) => {
+    const record = asRecord(entry);
+    const message = [
+      getString(record.text),
+      getString(record.message),
+      getString(record.value)
+    ].find((value) => typeof value === "string" && value.trim().length > 0);
+    return {
+      level: (getString(record.level) ?? getString(record.type) ?? "log").toLowerCase(),
+      message: message?.trim() ?? ""
+    };
+  }).filter((entry) => entry.message.length > 0);
+  const latest = events.slice(-3).reverse().map((entry) => ({
+    level: entry.level,
+    message: entry.message
+  }));
+  return {
+    eventCount: channel.events.length,
+    nextSeq: channel.nextSeq,
+    truncated: channel.truncated,
+    errorCount: events.filter((entry) => entry.level.includes("error")).length,
+    warningCount: events.filter((entry) => entry.level.includes("warn")).length,
+    latest
+  };
+}
+function summarizeNetwork(channel) {
+  const normalized = channel.events.map((entry) => {
+    const record = asRecord(entry);
+    return {
+      status: getNumber(record.status) ?? void 0,
+      method: getString(record.method) ?? void 0,
+      url: getString(record.url) ?? void 0,
+      error: getString(record.errorText) ?? getString(record.error) ?? void 0
+    };
+  });
+  const failures = normalized.filter((entry) => typeof entry.status === "number" && entry.status >= 400 || typeof entry.error === "string");
+  return {
+    eventCount: channel.events.length,
+    nextSeq: channel.nextSeq,
+    truncated: channel.truncated,
+    failureCount: failures.length,
+    latestFailures: failures.slice(-3).reverse()
+  };
+}
+function summarizeRelay(relay) {
+  return {
+    running: relay.running,
+    ...typeof relay.port === "number" ? { port: relay.port } : {},
+    extensionConnected: relay.extensionConnected,
+    extensionHandshakeComplete: relay.extensionHandshakeComplete,
+    annotationConnected: relay.annotationConnected,
+    opsConnected: relay.opsConnected,
+    canvasConnected: relay.canvasConnected,
+    cdpConnected: relay.cdpConnected,
+    pairingRequired: relay.pairingRequired,
+    health: relay.health
+  };
+}
+function deriveHealthState(input) {
+  if (input.blockerState === "active" || input.dialogOpen || input.activeTargetId === null || input.mode === "extension" && input.relay && !input.relay.extensionHandshakeComplete && input.relay.extensionConnected) {
+    return "blocked";
+  }
+  if (input.relay && !input.relay.health.ok || input.consoleErrors > 0 || input.networkFailures > 0 || input.exceptionCount > 0) {
+    return "warning";
+  }
+  return "ok";
+}
+function deriveSuggestedNextAction(input) {
+  if (input.dialogOpen) {
+    return "Handle the open dialog before continuing any page interaction.";
+  }
+  if (input.mode === "extension" && input.relay && !input.relay.extensionHandshakeComplete) {
+    return "Re-establish a clean daemon-extension handshake: open the extension popup, click Connect again, confirm `status --daemon` shows ext=on and handshake=on, then retry the next page action.";
+  }
+  if (input.blockerState === "active") {
+    return "Resolve the active blocker or challenge before issuing more page actions.";
+  }
+  if (input.activeTargetId === null) {
+    return "Create or select a target before continuing the next automation step.";
+  }
+  if (input.consoleErrors > 0 || input.networkFailures > 0 || input.exceptionCount > 0) {
+    return "Inspect the summarized trace failures, fix the page instability, then rerun snapshot or review.";
+  }
+  return "Capture snapshot or review and continue the normal snapshot -> action -> snapshot loop.";
+}
+function readBlockerState(traceMeta, sessionMeta) {
+  const raw = getString(traceMeta.blockerState) ?? sessionMeta?.blockerState ?? "clear";
+  return raw === "active" || raw === "resolving" ? raw : "clear";
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function getNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function getBoolean(value) {
+  return typeof value === "boolean" ? value : null;
+}
+
+// src/inspiredesign/capture.ts
+var INSPIREDESIGN_CAPTURE_TIMEOUT_MS = 3e4;
+var INSPIREDESIGN_CAPTURE_MAX_CHARS = 12e3;
+var ACTIVE_SESSION_COOKIE_REUSE_UNAVAILABLE_MESSAGE = "Deep capture only honors configured provider cookie sources; active session cookies are not reused.";
+var DOM_CAPTURE_HELPER_UNAVAILABLE_MESSAGE = "DOM capture helper unavailable in this execution lane.";
+var SNAPSHOT_CAPTURE_EMPTY_MESSAGE = "Snapshot capture returned empty content.";
+var CLONE_CAPTURE_EMPTY_MESSAGE = "Clone capture returned empty component and CSS previews.";
+var DOM_CAPTURE_EMPTY_MESSAGE = "DOM capture returned empty HTML.";
+var SKIPPED_AFTER_TRANSPORT_TIMEOUT_SUFFIX = "transport timeout.";
+var createRemainingCaptureTimeout = (timeoutMs) => {
+  const startedAtMs = Date.now();
+  let firstRead = true;
+  return () => {
+    if (firstRead) {
+      firstRead = false;
+      return timeoutMs;
+    }
+    return Math.max(1, timeoutMs - Math.max(0, Date.now() - startedAtMs));
+  };
+};
+var clampInspiredesignCaptureTimeout = (timeoutMs) => {
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) return INSPIREDESIGN_CAPTURE_TIMEOUT_MS;
+  return Math.max(1, Math.min(timeoutMs, INSPIREDESIGN_CAPTURE_TIMEOUT_MS));
+};
+function sanitizeInspiredesignCaptureText(value) {
+  if (value === void 0) return void 0;
+  const redacted = redactSensitive(value);
+  return typeof redacted === "string" ? redacted : value;
+}
+var buildCaptureAttempt = (status, detail) => {
+  const sanitizedDetail = sanitizeInspiredesignCaptureText(detail);
+  return sanitizedDetail ? { status, detail: sanitizedDetail } : { status };
+};
+var detailFromCaptureError = (error, fallback) => {
+  return error instanceof Error ? error.message : fallback;
+};
+var isTransportTimeoutError = (error, detail) => {
+  if (error instanceof Error) {
+    const code = error.code;
+    if (error.name === "TimeoutError" || code === "ETIMEDOUT" || code === "ERR_HTTP_REQUEST_TIMEOUT") {
+      return true;
+    }
+  }
+  return /\btimed out after \d+ms\b/i.test(detail) || /exceeded timeout budget\./i.test(detail);
+};
+var isIgnorableNetworkIdleWaitError = (error) => {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return /timed out|timeout/i.test(error.message);
+};
+var buildSkippedAfterTransportTimeoutAttempt = (label) => {
+  return buildCaptureAttempt("skipped", `Skipped after ${label} ${SKIPPED_AFTER_TRANSPORT_TIMEOUT_SUFFIX}`);
+};
+var hasUsableCaptureText = (value) => {
+  return typeof value === "string" && value.trim().length > 0;
+};
+var resolveInspiredesignCaptureCookiePolicy = (options) => {
+  if (options.cookiePolicyOverride) return options.cookiePolicyOverride;
+  return options.useCookies === false ? "off" : "auto";
+};
+var withCaptureDeadline = async (promise, timeoutMs, label) => {
+  let clearDeadline = () => {
+  };
+  const timeoutPromise = new Promise((_, reject) => {
+    const handle = setTimeout(() => reject(new Error(`Deep capture ${label} exceeded timeout budget.`)), timeoutMs);
+    clearDeadline = () => clearTimeout(handle);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearDeadline();
+  }
+};
+var verifyRequiredCaptureCookies = async (manager, sessionId, url, importState, timeoutMs) => {
+  const cookies = await withCaptureDeadline(
+    manager.cookieList(sessionId, [url], void 0, timeoutMs),
+    timeoutMs,
+    "cookie verification"
+  );
+  if (cookies.count > 0) return;
+  if (!importState.sourceConfigured) {
+    throw new Error(ACTIVE_SESSION_COOKIE_REUSE_UNAVAILABLE_MESSAGE);
+  }
+  const sourceDetail = importState.sourceMessage ? ` ${importState.sourceMessage}` : "";
+  throw new Error(`Deep capture requires observable cookies from the configured provider cookie source for the requested URL.${sourceDetail}`);
+};
+var importConfiguredCaptureCookies = async (manager, sessionId, source, timeoutMs) => {
+  if (!source || typeof manager.cookieImport !== "function") {
+    return {
+      sourceConfigured: Boolean(source),
+      sourceAvailable: false
+    };
+  }
+  const loaded = await readCookiesFromSource(source);
+  if (loaded.cookies.length === 0) {
+    return {
+      sourceConfigured: true,
+      sourceAvailable: loaded.available,
+      sourceMessage: loaded.message
+    };
+  }
+  await withCaptureDeadline(
+    manager.cookieImport(sessionId, loaded.cookies, false, void 0, timeoutMs),
+    timeoutMs,
+    "cookie import"
+  );
+  return {
+    sourceConfigured: true,
+    sourceAvailable: loaded.available,
+    sourceMessage: loaded.message
+  };
+};
+var captureSnapshotArtifact = async (manager, sessionId, remainingTimeoutMs) => {
+  try {
+    const snapshot = await withCaptureDeadline(
+      manager.snapshot(
+        sessionId,
+        "actionables",
+        INSPIREDESIGN_CAPTURE_MAX_CHARS,
+        void 0,
+        void 0,
+        remainingTimeoutMs()
+      ),
+      remainingTimeoutMs(),
+      "snapshot capture"
+    );
+    const content = sanitizeInspiredesignCaptureText(snapshot.content) ?? "";
+    if (!hasUsableCaptureText(content)) {
+      return {
+        attempt: buildCaptureAttempt("failed", SNAPSHOT_CAPTURE_EMPTY_MESSAGE)
+      };
+    }
+    return {
+      attempt: buildCaptureAttempt("captured"),
+      snapshot: {
+        content,
+        refCount: snapshot.refCount,
+        warnings: snapshot.warnings ?? []
+      }
+    };
+  } catch (error) {
+    const detail = detailFromCaptureError(error, "Snapshot capture failed.");
+    return {
+      attempt: buildCaptureAttempt("failed", detail),
+      ...isTransportTimeoutError(error, detail) ? { transportTimedOut: true } : {}
+    };
+  }
+};
+var captureCloneArtifact = async (manager, sessionId, remainingTimeoutMs) => {
+  try {
+    const clone = await withCaptureDeadline(
+      manager.clonePage(sessionId, void 0, remainingTimeoutMs()),
+      remainingTimeoutMs(),
+      "clone capture"
+    );
+    const componentPreview = sanitizeInspiredesignCaptureText(clone.component) ?? "";
+    const cssPreview = sanitizeInspiredesignCaptureText(clone.css) ?? "";
+    if (!hasUsableCaptureText(componentPreview) && !hasUsableCaptureText(cssPreview)) {
+      return {
+        attempt: buildCaptureAttempt("failed", CLONE_CAPTURE_EMPTY_MESSAGE)
+      };
+    }
+    return {
+      attempt: buildCaptureAttempt("captured"),
+      clone: {
+        componentPreview,
+        cssPreview,
+        warnings: clone.warnings ?? []
+      }
+    };
+  } catch (error) {
+    const detail = detailFromCaptureError(error, "Clone capture failed.");
+    return {
+      attempt: buildCaptureAttempt("failed", detail),
+      ...isTransportTimeoutError(error, detail) ? { transportTimedOut: true } : {}
+    };
+  }
+};
+var captureDomArtifact = async (manager, sessionId, remainingTimeoutMs) => {
+  if (typeof manager.clonePageHtmlWithOptions !== "function") {
+    return {
+      attempt: buildCaptureAttempt("skipped", DOM_CAPTURE_HELPER_UNAVAILABLE_MESSAGE)
+    };
+  }
+  try {
+    const dom = await withCaptureDeadline(
+      manager.clonePageHtmlWithOptions(sessionId, void 0, void 0, remainingTimeoutMs()),
+      remainingTimeoutMs(),
+      "DOM capture"
+    );
+    const outerHTML = sanitizeInspiredesignCaptureText(dom.html) ?? "";
+    if (!hasUsableCaptureText(outerHTML)) {
+      return {
+        attempt: buildCaptureAttempt("failed", DOM_CAPTURE_EMPTY_MESSAGE)
+      };
+    }
+    return {
+      attempt: buildCaptureAttempt("captured"),
+      dom: {
+        outerHTML,
+        truncated: false
+      }
+    };
+  } catch (error) {
+    const detail = detailFromCaptureError(error, "DOM capture failed.");
+    return {
+      attempt: buildCaptureAttempt("failed", detail),
+      ...isTransportTimeoutError(error, detail) ? { transportTimedOut: true } : {}
+    };
+  }
+};
+var buildCaptureEvidence = (snapshot, clone, dom) => {
+  const attempts = {
+    snapshot: snapshot.attempt,
+    clone: clone.attempt,
+    dom: dom.attempt
+  };
+  return {
+    ...snapshot.snapshot ? { snapshot: snapshot.snapshot } : {},
+    ...dom.dom ? { dom: dom.dom } : {},
+    ...clone.clone ? { clone: clone.clone } : {},
+    attempts
+  };
+};
+var buildTransportTimeoutCaptureEvidence = (snapshot, clone, label) => {
+  const attempts = {
+    snapshot: snapshot.attempt,
+    clone: clone?.attempt ?? buildSkippedAfterTransportTimeoutAttempt(label),
+    dom: buildSkippedAfterTransportTimeoutAttempt(label)
+  };
+  return {
+    ...snapshot.snapshot ? { snapshot: snapshot.snapshot } : {},
+    ...clone?.clone ? { clone: clone.clone } : {},
+    attempts
+  };
+};
+var captureInspiredesignArtifacts = async (manager, sessionId, remainingTimeoutMs) => {
+  const snapshot = await captureSnapshotArtifact(manager, sessionId, remainingTimeoutMs);
+  if (snapshot.transportTimedOut) {
+    return buildTransportTimeoutCaptureEvidence(snapshot, void 0, "snapshot capture");
+  }
+  const clone = await captureCloneArtifact(manager, sessionId, remainingTimeoutMs);
+  if (clone.transportTimedOut) {
+    return buildTransportTimeoutCaptureEvidence(snapshot, clone, "clone capture");
+  }
+  const dom = await captureDomArtifact(manager, sessionId, remainingTimeoutMs);
+  return buildCaptureEvidence(snapshot, clone, dom);
+};
+async function captureInspiredesignReferenceFromManager(manager, url, options = {}) {
+  const cookiePolicy = resolveInspiredesignCaptureCookiePolicy(options);
+  const captureTimeoutMs = clampInspiredesignCaptureTimeout(options.timeoutMs);
+  const remainingTimeoutMs = createRemainingCaptureTimeout(captureTimeoutMs);
+  const launchTimeoutMs = remainingTimeoutMs();
+  const session = await withCaptureDeadline(
+    manager.launch({
+      headless: true,
+      startUrl: "about:blank",
+      persistProfile: false,
+      noExtension: true
+    }, launchTimeoutMs),
+    launchTimeoutMs,
+    "session launch"
+  );
+  try {
+    const importState = cookiePolicy === "off" ? { sourceConfigured: false, sourceAvailable: false } : await importConfiguredCaptureCookies(
+      manager,
+      session.sessionId,
+      options.cookieSource,
+      remainingTimeoutMs()
+    );
+    if (cookiePolicy === "required") {
+      await verifyRequiredCaptureCookies(
+        manager,
+        session.sessionId,
+        url,
+        importState,
+        remainingTimeoutMs()
+      );
+    }
+    manager.setSessionChallengeAutomationMode?.(session.sessionId, options.challengeAutomationMode);
+    const gotoTimeoutMs = remainingTimeoutMs();
+    await withCaptureDeadline(
+      manager.goto(session.sessionId, url, "load", gotoTimeoutMs),
+      gotoTimeoutMs,
+      "navigation"
+    );
+    const waitTimeoutMs = remainingTimeoutMs();
+    try {
+      await withCaptureDeadline(
+        manager.waitForLoad(session.sessionId, "networkidle", waitTimeoutMs),
+        waitTimeoutMs,
+        "network idle wait"
+      );
+    } catch (error) {
+      if (!isIgnorableNetworkIdleWaitError(error)) {
+        throw error;
+      }
+    }
+    return await captureInspiredesignArtifacts(manager, session.sessionId, remainingTimeoutMs);
+  } finally {
+    await manager.disconnect(session.sessionId, true).catch(() => void 0);
+  }
+}
+
+// src/macros/execute.ts
+var buildRuntimePolicyOverrides = (overrides) => {
+  if (!overrides) {
+    return void 0;
+  }
+  const runtimePolicy = {
+    ...overrides.browserMode ? { browserMode: overrides.browserMode } : {},
+    ...typeof overrides.useCookies === "boolean" ? { useCookies: overrides.useCookies } : {},
+    ...overrides.cookiePolicyOverride ? { cookiePolicyOverride: overrides.cookiePolicyOverride } : {}
+  };
+  return Object.keys(runtimePolicy).length > 0 ? runtimePolicy : void 0;
+};
+var isRecordValue = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var requireMacroString = (value, label) => {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`Macro action missing ${label}`);
+  }
+  return value;
+};
+var optionalPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+var optionalBoolean = (value) => typeof value === "boolean" ? value : void 0;
+var optionalJsonRecord = (value) => isRecordValue(value) ? value : void 0;
+var optionalStringArray = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const parsed = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
+  return parsed.length > 0 ? parsed : void 0;
+};
+var normalizePlainText = (value) => typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+var REDDIT_VERIFICATION_WALL_RE = /\b(?:please wait for verification|verify you are human|security check)\b/i;
+var readTargetedSocialPlatform = (providerId) => {
+  switch (providerId) {
+    case "social/x":
+      return "x";
+    case "social/bluesky":
+      return "bluesky";
+    case "social/reddit":
+      return "reddit";
+    case "social/facebook":
+      return "facebook";
+    case "social/threads":
+      return "threads";
+    default:
+      return null;
+  }
+};
+var getMacroShellReason = (record, providerId, fallbackRetrievalPath) => {
+  const url = normalizePlainText(record?.url).toLowerCase();
+  const title = normalizePlainText(record?.title);
+  const content = normalizePlainText(record?.content);
+  const combined = `${title} ${content}`.trim().toLowerCase();
+  const retrievalPath = normalizePlainText(
+    typeof record?.attributes?.retrievalPath === "string" ? record.attributes.retrievalPath : fallbackRetrievalPath
+  ).toLowerCase();
+  const extractionQuality = optionalJsonRecord(record?.attributes?.extractionQuality);
+  const contentChars = Number(extractionQuality?.contentChars ?? content.length);
+  const links = optionalStringArray(record?.attributes?.links) ?? [];
+  if (combined.includes("bots use duckduckgo too") || combined.includes("please complete the following challenge") || combined.includes("select all squares containing a duck")) {
+    return "challenge_shell";
+  }
+  const socialPlatform = readTargetedSocialPlatform(providerId);
+  if (socialPlatform) {
+    const socialShell = detectSocialSearchShell(socialPlatform, {
+      url,
+      title,
+      content,
+      links
+    });
+    if (socialShell) {
+      return socialShell.providerShell;
+    }
+  }
+  if (url.includes("reddit.com") && REDDIT_VERIFICATION_WALL_RE.test(combined)) {
+    return "challenge_shell";
+  }
+  if (retrievalPath === "web:search:index" && (url.includes("duckduckgo.com") || title.toLowerCase().includes("duckduckgo"))) {
+    return "search_shell";
+  }
+  if (providerId === "web/default" && (retrievalPath === "web:fetch:url" || retrievalPath.startsWith("fetch:")) && contentChars > 0 && contentChars <= 8 && links.length >= 20) {
+    return "truncated_fetch_shell";
+  }
+  if (providerId === "social/youtube" && (url.includes("youtube.com/watch") && combined.includes("about press copyright contact us creators advertise developers terms privacy policy") || url.includes("developers.google.com/youtube") && combined.includes("google for developers skip to main content youtube"))) {
+    return "generic_shell";
+  }
+  return null;
+};
+var assertMacroExecutionQuality = (resolution, result) => {
+  if (!Array.isArray(result.records) || result.records.length === 0 || result.failures.length > 0) {
+    return;
+  }
+  const providerId = typeof resolution.action.input.providerId === "string" && resolution.action.input.providerId.trim() ? resolution.action.input.providerId.trim() : resolution.provenance.provider;
+  const fallbackRetrievalPath = normalizePlainText(
+    optionalJsonRecord(result.meta?.provenance)?.retrievalPath
+  );
+  const reasons = result.records.map((record) => getMacroShellReason(record, providerId, fallbackRetrievalPath)).filter((reason) => typeof reason === "string");
+  if (reasons.length !== result.records.length) {
+    return;
+  }
+  throw new Error(`Macro execution returned only shell records (${[...new Set(reasons)].join(",")}).`);
+};
+var partitionMacroExecutionRecords = (records, providerId, fallbackRetrievalPath) => {
+  const usable = [];
+  const shell = [];
+  for (const record of records) {
+    const reason = getMacroShellReason(record, providerId, fallbackRetrievalPath);
+    if (reason) {
+      shell.push({ record, reason });
+    } else {
+      usable.push(record);
+    }
+  }
+  return { usable, shell };
+};
+var prioritizeMacroExecutionRecords = (resolution, result) => {
+  if (!Array.isArray(result.records) || result.records.length <= 1) {
+    return result;
+  }
+  const providerId = typeof resolution.action.input.providerId === "string" && resolution.action.input.providerId.trim() ? resolution.action.input.providerId.trim() : resolution.provenance.provider;
+  const fallbackRetrievalPath = normalizePlainText(
+    optionalJsonRecord(result.meta?.provenance)?.retrievalPath
+  );
+  const { usable, shell } = partitionMacroExecutionRecords(result.records, providerId, fallbackRetrievalPath);
+  if (usable.length === 0 || shell.length === 0) {
+    return result;
+  }
+  return {
+    ...result,
+    records: [
+      ...usable,
+      ...shell.map((entry) => entry.record)
+    ]
+  };
+};
+var normalizeSearchInput = (input) => {
+  const query = requireMacroString(input.query, "search.query");
+  const limit = optionalPositiveInteger(input.limit);
+  const filters = optionalJsonRecord(input.filters);
+  return {
+    query,
+    ...limit !== void 0 ? { limit } : {},
+    ...filters ? { filters } : {}
+  };
+};
+var normalizeFetchInput = (input) => {
+  const url = requireMacroString(input.url, "fetch.url");
+  const filters = optionalJsonRecord(input.filters);
+  return {
+    url,
+    ...filters ? { filters } : {}
+  };
+};
+var normalizeCrawlInput = (input) => {
+  const seedUrls = optionalStringArray(input.seedUrls);
+  if (!seedUrls || seedUrls.length === 0) {
+    throw new Error("Macro action missing crawl.seedUrls");
+  }
+  const strategy = input.strategy === "bfs" || input.strategy === "dfs" ? input.strategy : void 0;
+  const maxDepth = optionalPositiveInteger(input.maxDepth);
+  const maxPages = optionalPositiveInteger(input.maxPages);
+  const maxPerDomain = optionalPositiveInteger(input.maxPerDomain);
+  const filters = optionalJsonRecord(input.filters);
+  return {
+    seedUrls,
+    ...strategy ? { strategy } : {},
+    ...maxDepth !== void 0 ? { maxDepth } : {},
+    ...maxPages !== void 0 ? { maxPages } : {},
+    ...maxPerDomain !== void 0 ? { maxPerDomain } : {},
+    ...filters ? { filters } : {}
+  };
+};
+var normalizePostInput = (input) => {
+  const target = requireMacroString(input.target, "post.target");
+  const content = requireMacroString(input.content, "post.content");
+  const mediaUrls = optionalStringArray(input.mediaUrls);
+  const confirm = optionalBoolean(input.confirm);
+  const riskAccepted = optionalBoolean(input.riskAccepted);
+  const metadata = optionalJsonRecord(input.metadata);
+  return {
+    target,
+    content,
+    ...mediaUrls ? { mediaUrls } : {},
+    ...confirm !== void 0 ? { confirm } : {},
+    ...riskAccepted !== void 0 ? { riskAccepted } : {},
+    ...metadata ? { metadata } : {}
+  };
+};
+var buildRunOptions = (resolution, overrides) => {
+  const source = resolution.action.source;
+  const providerId = typeof resolution.action.input.providerId === "string" && resolution.action.input.providerId.trim() ? resolution.action.input.providerId.trim() : void 0;
+  const runtimePolicy = buildRuntimePolicyOverrides(overrides);
+  return {
+    source,
+    ...providerId ? { providerIds: [providerId] } : {},
+    ...overrides?.challengeAutomationMode ? { challengeAutomationMode: overrides.challengeAutomationMode } : {},
+    ...runtimePolicy ? { runtimePolicy } : {}
+  };
+};
+var executeMacroResolution = async (resolution, runtime, overrides) => {
+  const { operation, input } = resolution.action;
+  if (!isRecordValue(input)) {
+    throw new Error("Macro action input is invalid");
+  }
+  const options = buildRunOptions(resolution, overrides);
+  let result;
+  switch (operation) {
+    case "search":
+      result = await runtime.search(normalizeSearchInput(input), options);
+      break;
+    case "fetch":
+      result = await runtime.fetch(normalizeFetchInput(input), options);
+      break;
+    case "crawl":
+      result = await runtime.crawl(normalizeCrawlInput(input), options);
+      break;
+    case "post":
+      result = await runtime.post(normalizePostInput(input), options);
+      break;
+    default:
+      throw new Error(`Macro operation is not supported: ${operation}`);
+  }
+  const prioritized = prioritizeMacroExecutionRecords(resolution, result);
+  assertMacroExecutionQuality(resolution, prioritized);
+  return prioritized;
+};
+var shapeExecutionPayload = (result) => {
+  return {
+    records: result.records,
+    failures: result.failures,
+    metrics: result.metrics,
+    meta: {
+      ok: result.ok,
+      partial: result.partial,
+      sourceSelection: result.sourceSelection,
+      providerOrder: result.providerOrder,
+      trace: result.trace,
+      ...result.meta?.tier ? { tier: result.meta.tier } : {},
+      ...result.meta?.provenance ? { provenance: result.meta.provenance } : {},
+      ...result.meta?.blocker ? { blocker: result.meta.blocker } : {},
+      ...result.error ? { error: result.error } : {}
+    },
+    ...result.diagnostics ? { diagnostics: result.diagnostics } : {}
+  };
+};
+
+// src/macros/execute-runtime.ts
+var MACRO_TIMEOUT_MIN_MS = 1e3;
+var MACRO_TIMEOUT_MAX_MS = 3e5;
+var clampMacroRuntimeTimeout = (timeoutMs) => {
+  if (!Number.isFinite(timeoutMs ?? NaN)) {
+    return null;
+  }
+  const parsed = Math.floor(timeoutMs);
+  return Math.max(MACRO_TIMEOUT_MIN_MS, Math.min(MACRO_TIMEOUT_MAX_MS, parsed));
+};
+var buildMacroRuntimeInit = (timeoutMs) => {
+  const macroTimeoutMs = clampMacroRuntimeTimeout(timeoutMs);
+  if (macroTimeoutMs === null) {
+    return void 0;
+  }
+  return {
+    budgets: {
+      timeoutMs: {
+        search: macroTimeoutMs,
+        fetch: macroTimeoutMs,
+        crawl: macroTimeoutMs,
+        post: macroTimeoutMs
+      }
+    }
+  };
+};
+var executeMacroWithRuntime = async (args) => {
+  const runtime = args.runtime ?? resolveBundledProviderRuntime({
+    existingRuntime: args.existingRuntime,
+    config: args.config,
+    manager: args.manager,
+    browserFallbackPort: args.browserFallbackPort,
+    init: buildMacroRuntimeInit(args.timeoutMs)
+  });
+  return shapeExecutionPayload(
+    await executeMacroResolution(
+      args.resolution,
+      runtime,
+      args.challengeAutomationMode || args.browserMode || typeof args.useCookies === "boolean" || args.cookiePolicyOverride ? {
+        ...args.browserMode ? { browserMode: args.browserMode } : {},
+        ...typeof args.useCookies === "boolean" ? { useCookies: args.useCookies } : {},
+        ...args.challengeAutomationMode ? { challengeAutomationMode: args.challengeAutomationMode } : {},
+        ...args.cookiePolicyOverride ? { cookiePolicyOverride: args.cookiePolicyOverride } : {}
+      } : void 0
+    )
+  );
+};
+
+// src/cli/daemon-state.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var HUB_INSTANCE_ID = randomUUID2();
+var BINDING_TTL_MS = 6e4;
+var RENEW_INTERVAL_MS = 2e4;
+var RENEW_GRACE_MS = RENEW_INTERVAL_MS * 2;
+var RENEW_JITTER_MS = 2e3;
+var WAIT_MAX_MS = 3e4;
+var binding = null;
+var queue = [];
+var sessionLeases = /* @__PURE__ */ new Map();
+var screencastOwners = /* @__PURE__ */ new Map();
+var screencastOwnerCleanupTimers = /* @__PURE__ */ new Map();
+var getHubInstanceId = () => HUB_INSTANCE_ID;
+var nowMs = () => Date.now();
+var isExpired = (state) => nowMs() > state.expiresAt + RENEW_GRACE_MS;
+var computeRenewAfterMs = () => {
+  const jitter = Math.floor((Math.random() * 2 - 1) * RENEW_JITTER_MS);
+  return Math.max(1e3, RENEW_INTERVAL_MS + jitter);
+};
+var serializeBinding = (state) => ({
+  bindingId: state.bindingId,
+  expiresAt: new Date(state.expiresAt).toISOString(),
+  ttlMs: BINDING_TTL_MS,
+  renewAfterMs: computeRenewAfterMs()
+});
+var serializeQueue = (entry) => ({
+  queued: true,
+  position: queue.findIndex((item) => item.clientId === entry.clientId) + 1,
+  waitUntil: new Date(entry.timeoutAt).toISOString(),
+  waitMs: Math.max(0, entry.timeoutAt - nowMs())
+});
+var cleanupQueue = () => {
+  const now = nowMs();
+  queue = queue.filter((entry) => entry.timeoutAt > now);
+};
+var clearScreencastOwnerCleanup = (screencastId) => {
+  const timer = screencastOwnerCleanupTimers.get(screencastId);
+  if (!timer) {
+    return;
+  }
+  clearTimeout(timer);
+  screencastOwnerCleanupTimers.delete(screencastId);
+};
+var releaseTrackedScreencastOwner = (screencastId) => {
+  clearScreencastOwnerCleanup(screencastId);
+  screencastOwners.delete(screencastId);
+};
+var isExpiredScreencastOwner = (owner) => {
+  return owner.completedAt !== null && owner.lastUsedAt + SCREENCAST_RETENTION_MS <= nowMs();
+};
+var scheduleScreencastOwnerCleanup = (owner) => {
+  clearScreencastOwnerCleanup(owner.screencastId);
+  if (owner.completedAt === null) {
+    return;
+  }
+  const timer = setTimeout(() => {
+    if (isExpiredScreencastOwner(owner) && screencastOwners.get(owner.screencastId) === owner) {
+      screencastOwners.delete(owner.screencastId);
+    }
+    screencastOwnerCleanupTimers.delete(owner.screencastId);
+  }, SCREENCAST_RETENTION_MS);
+  timer.unref?.();
+  screencastOwnerCleanupTimers.set(owner.screencastId, timer);
+};
+var cleanupScreencastOwners = () => {
+  for (const [screencastId, owner] of screencastOwners.entries()) {
+    if (isExpiredScreencastOwner(owner)) {
+      releaseTrackedScreencastOwner(screencastId);
+    }
+  }
+};
+var getQueueEntry = (clientId) => {
+  return queue.find((entry) => entry.clientId === clientId) ?? null;
+};
+var enqueueClient = (clientId) => {
+  cleanupQueue();
+  const existing = getQueueEntry(clientId);
+  if (existing) {
+    return existing;
+  }
+  const entry = {
+    clientId,
+    requestedAt: nowMs(),
+    timeoutAt: nowMs() + WAIT_MAX_MS
+  };
+  queue.push(entry);
+  return entry;
+};
+var dequeueClient = (clientId) => {
+  queue = queue.filter((entry) => entry.clientId !== clientId);
+};
+var maybeGrantBinding = (clientId) => {
+  const existing = getBindingState();
+  const now = nowMs();
+  if (existing) {
+    if (existing.clientId !== clientId) {
+      return null;
+    }
+    existing.expiresAt = now + BINDING_TTL_MS;
+    existing.lastRenewedAt = now;
+    return serializeBinding(existing);
+  }
+  cleanupQueue();
+  const head = queue[0];
+  if (head && head.clientId !== clientId) {
+    return null;
+  }
+  if (head && head.clientId === clientId) {
+    queue.shift();
+  }
+  const state = {
+    bindingId: randomUUID2(),
+    clientId: clientId.trim(),
+    expiresAt: now + BINDING_TTL_MS,
+    lastRenewedAt: now
+  };
+  binding = state;
+  return serializeBinding(state);
+};
+var getBindingState = () => {
+  if (binding && isExpired(binding)) {
+    binding = null;
+  }
+  cleanupQueue();
+  return binding;
+};
+var clearBinding = () => {
+  binding = null;
+  queue = [];
+};
+var registerSessionLease = (sessionId, leaseId, clientId) => {
+  if (!sessionId || !sessionId.trim()) {
+    throw new Error("RELAY_SESSION_REQUIRED: sessionId is required");
+  }
+  if (!leaseId || !leaseId.trim()) {
+    throw new Error("RELAY_LEASE_REQUIRED: leaseId is required");
+  }
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  const lease = {
+    sessionId,
+    leaseId,
+    clientId: clientId.trim(),
+    createdAt: nowMs(),
+    lastUsedAt: nowMs()
+  };
+  sessionLeases.set(sessionId, lease);
+  return lease;
+};
+var getSessionLease = (sessionId) => {
+  if (!sessionId || !sessionId.trim()) return null;
+  return sessionLeases.get(sessionId) ?? null;
+};
+var releaseSessionLease = (sessionId) => {
+  sessionLeases.delete(sessionId);
+};
+var releaseOwnedSessionLease = (sessionId, clientId, leaseId) => {
+  if (!sessionId || !sessionId.trim()) return false;
+  if (!clientId || !clientId.trim()) return false;
+  const lease = sessionLeases.get(sessionId);
+  if (!lease) return false;
+  const normalizedClientId = clientId.trim();
+  const normalizedLeaseId = leaseId?.trim() ?? "";
+  if (lease.clientId !== normalizedClientId) return false;
+  if (normalizedLeaseId && lease.leaseId !== normalizedLeaseId) return false;
+  sessionLeases.delete(sessionId);
+  return true;
+};
+var registerScreencastOwner = (sessionId, screencastId, clientId) => {
+  if (!sessionId || !sessionId.trim()) {
+    throw new Error("RELAY_SESSION_REQUIRED: sessionId is required");
+  }
+  if (!screencastId || !screencastId.trim()) {
+    throw new Error("RELAY_SCREENCAST_REQUIRED: screencastId is required");
+  }
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  cleanupScreencastOwners();
+  const createdAt = nowMs();
+  const owner = {
+    screencastId: screencastId.trim(),
+    sessionId: sessionId.trim(),
+    clientId: clientId.trim(),
+    createdAt,
+    completedAt: null,
+    lastUsedAt: createdAt
+  };
+  releaseTrackedScreencastOwner(owner.screencastId);
+  screencastOwners.set(owner.screencastId, owner);
+  return owner;
+};
+var getScreencastOwner = (screencastId) => {
+  if (!screencastId || !screencastId.trim()) return null;
+  cleanupScreencastOwners();
+  return screencastOwners.get(screencastId) ?? null;
+};
+var touchScreencastOwner = (screencastId) => {
+  const owner = getScreencastOwner(screencastId);
+  if (!owner) {
+    return null;
+  }
+  owner.lastUsedAt = nowMs();
+  scheduleScreencastOwnerCleanup(owner);
+  return owner;
+};
+var completeScreencastOwner = (screencastId) => {
+  const owner = getScreencastOwner(screencastId);
+  if (!owner) {
+    return null;
+  }
+  const completedAt = nowMs();
+  owner.completedAt = completedAt;
+  owner.lastUsedAt = completedAt;
+  scheduleScreencastOwnerCleanup(owner);
+  return owner;
+};
+var requireScreencastOwner = (sessionId, screencastId, clientId) => {
+  if (!sessionId || !sessionId.trim()) {
+    throw new Error("RELAY_SESSION_REQUIRED: sessionId is required");
+  }
+  if (!screencastId || !screencastId.trim()) {
+    throw new Error("RELAY_SCREENCAST_REQUIRED: screencastId is required");
+  }
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  const owner = getScreencastOwner(screencastId);
+  if (!owner) {
+    throw new Error("RELAY_SCREENCAST_OWNER_REQUIRED: No retained owner for completed screencast retrieval.");
+  }
+  const normalizedSessionId = sessionId.trim();
+  const normalizedClientId = clientId.trim();
+  if (owner.sessionId !== normalizedSessionId || owner.clientId !== normalizedClientId) {
+    throw new Error("RELAY_SCREENCAST_OWNER_INVALID: Screencast does not match the current owner.");
+  }
+  touchScreencastOwner(screencastId);
+  return owner;
+};
+var requireSessionLease = (sessionId, clientId, leaseId) => {
+  if (!sessionId || !sessionId.trim()) {
+    throw new Error("RELAY_SESSION_REQUIRED: sessionId is required");
+  }
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  const lease = sessionLeases.get(sessionId);
+  if (!lease) {
+    throw new Error("RELAY_LEASE_REQUIRED: No active lease for session.");
+  }
+  const normalizedClientId = clientId.trim();
+  const normalizedLeaseId = leaseId?.trim() ?? "";
+  if (!normalizedLeaseId) {
+    if (lease.clientId !== normalizedClientId) {
+      throw new Error("RELAY_LEASE_INVALID: Lease does not match session owner.");
+    }
+    lease.lastUsedAt = nowMs();
+    return lease;
+  }
+  if (lease.leaseId !== normalizedLeaseId || lease.clientId !== normalizedClientId) {
+    throw new Error("RELAY_LEASE_INVALID: Lease does not match session owner.");
+  }
+  lease.lastUsedAt = nowMs();
+  return lease;
+};
+var bindRelay = (clientId) => {
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  const result = maybeGrantBinding(clientId);
+  if (result) {
+    return result;
+  }
+  const entry = enqueueClient(clientId.trim());
+  return serializeQueue(entry);
+};
+var waitForBinding = async (clientId, timeoutMs) => {
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  const entry = enqueueClient(clientId.trim());
+  const deadline = timeoutMs ? Math.min(entry.timeoutAt, nowMs() + timeoutMs) : entry.timeoutAt;
+  while (nowMs() <= deadline) {
+    const result = maybeGrantBinding(clientId);
+    if (result) {
+      return result;
+    }
+    cleanupQueue();
+    if (!getQueueEntry(clientId)) {
+      break;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 250));
+  }
+  dequeueClient(clientId);
+  throw new Error("RELAY_WAIT_TIMEOUT: Timed out waiting for relay binding.");
+};
+var renewRelay = (clientId, bindingId) => {
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  if (!bindingId || !bindingId.trim()) {
+    throw new Error("RELAY_BINDING_REQUIRED: bindingId is required");
+  }
+  const existing = getBindingState();
+  if (!existing) {
+    throw new Error("RELAY_BINDING_REQUIRED: No active binding to renew.");
+  }
+  if (existing.clientId !== clientId || existing.bindingId !== bindingId) {
+    throw new Error("RELAY_BINDING_INVALID: Binding does not match the current owner.");
+  }
+  const now = nowMs();
+  existing.expiresAt = now + BINDING_TTL_MS;
+  existing.lastRenewedAt = now;
+  return serializeBinding(existing);
+};
+var releaseRelay = (clientId, bindingId) => {
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  if (!bindingId || !bindingId.trim()) {
+    throw new Error("RELAY_BINDING_REQUIRED: bindingId is required");
+  }
+  const existing = getBindingState();
+  if (!existing) {
+    return { released: false };
+  }
+  if (existing.clientId !== clientId || existing.bindingId !== bindingId) {
+    throw new Error("RELAY_BINDING_INVALID: Binding does not match the current owner.");
+  }
+  binding = null;
+  return { released: true };
+};
+var requireBinding = (clientId, bindingId) => {
+  if (!clientId || !clientId.trim()) {
+    throw new Error("RELAY_CLIENT_ID_REQUIRED: clientId is required");
+  }
+  const existing = getBindingState();
+  if (!existing) {
+    throw new Error("RELAY_BINDING_REQUIRED: Call relay.bind to acquire the relay binding.");
+  }
+  if (!bindingId || !bindingId.trim()) {
+    throw new Error("RELAY_BINDING_REQUIRED: bindingId is required for relay operations.");
+  }
+  if (existing.clientId !== clientId || existing.bindingId !== bindingId) {
+    throw new Error("RELAY_BINDING_INVALID: Binding does not match the current owner.");
+  }
+  return existing;
+};
+var getBindingDiagnostics = () => {
+  const existing = getBindingState();
+  if (!existing) return null;
+  const expiresInMs = Math.max(0, existing.expiresAt - nowMs());
+  return {
+    bindingId: existing.bindingId,
+    clientId: existing.clientId,
+    expiresAt: new Date(existing.expiresAt).toISOString(),
+    expiresInMs,
+    queueLength: queue.length
+  };
+};
+var getBindingRenewConfig = () => ({
+  ttlMs: BINDING_TTL_MS,
+  renewIntervalMs: RENEW_INTERVAL_MS,
+  graceMs: RENEW_GRACE_MS,
+  waitMaxMs: WAIT_MAX_MS
+});
+
+// src/cli/daemon-commands.ts
+var createDaemonWorkflowRuntime = (core, options) => resolveBundledProviderRuntime({
+  existingRuntime: core.providerRuntime,
+  config: core.config,
+  manager: core.manager,
+  browserFallbackPort: core.browserFallbackPort,
+  init: options?.init
+});
+async function handleDaemonCommand(core, request) {
+  const params = request.params ?? {};
+  const bindingId = optionalString(params.bindingId);
+  try {
+    return await (async () => {
+      switch (request.name) {
+        case "relay.status":
+          return core.relay.status();
+        case "relay.cdpUrl":
+          return core.relay.getCdpUrl();
+        case "relay.annotationUrl":
+          return core.relay.getAnnotationUrl?.() ?? null;
+        case "relay.opsUrl":
+          return core.relay.getOpsUrl?.() ?? null;
+        case "relay.canvasUrl":
+          return core.relay.getCanvasUrl?.() ?? null;
+        case "canvas.execute":
+          return core.canvasManager.execute(
+            requireString(params.command, "command"),
+            requireRecord(params.params ?? {}, "params")
+          );
+        case "relay.bind": {
+          const clientId = requireClientId(params);
+          const binding2 = bindRelay(clientId);
+          const relayStatus = core.relay.status();
+          return {
+            ...binding2,
+            hubInstanceId: getHubInstanceId(),
+            relayInstanceId: relayStatus.instanceId,
+            relayPort: relayStatus.port ?? null,
+            bindingConfig: getBindingRenewConfig()
+          };
+        }
+        case "relay.wait": {
+          const clientId = requireClientId(params);
+          const timeoutMs = optionalNumber(params.timeoutMs, "timeoutMs");
+          const binding2 = await waitForBinding(clientId, timeoutMs);
+          const relayStatus = core.relay.status();
+          return {
+            ...binding2,
+            hubInstanceId: getHubInstanceId(),
+            relayInstanceId: relayStatus.instanceId,
+            relayPort: relayStatus.port ?? null,
+            bindingConfig: getBindingRenewConfig()
+          };
+        }
+        case "relay.renew": {
+          const clientId = requireClientId(params);
+          const binding2 = renewRelay(clientId, requireString(bindingId, "bindingId"));
+          const relayStatus = core.relay.status();
+          return {
+            ...binding2,
+            hubInstanceId: getHubInstanceId(),
+            relayInstanceId: relayStatus.instanceId,
+            relayPort: relayStatus.port ?? null,
+            bindingConfig: getBindingRenewConfig()
+          };
+        }
+        case "relay.release": {
+          const clientId = requireClientId(params);
+          return releaseRelay(clientId, requireString(bindingId, "bindingId"));
+        }
+        case "session.launch":
+          return launchWithRelay(core, params, requireClientId(params), bindingId);
+        case "session.connect":
+          return connectWithRelayRouting(core, params, requireClientId(params), bindingId);
+        case "session.disconnect":
+          return disconnectSession(core, params, requireClientId(params), bindingId);
+        case "session.status":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.status(requireString(params.sessionId, "sessionId"));
+        case "status.capabilities":
+          if (typeof params.sessionId === "string") {
+            await authorizeSessionCommand(core, params, request.name, bindingId);
+          }
+          return runStatusCapabilities(core, params);
+        case "session.inspect": {
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          const inspector = requireSessionInspectorHandle(core);
+          return inspectSession(inspector, {
+            sessionId: requireString(params.sessionId, "sessionId"),
+            includeUrls: optionalBoolean2(params.includeUrls) ?? true,
+            sinceConsoleSeq: optionalNumber(params.sinceConsoleSeq, "sinceConsoleSeq") ?? void 0,
+            sinceNetworkSeq: optionalNumber(params.sinceNetworkSeq, "sinceNetworkSeq") ?? void 0,
+            sinceExceptionSeq: optionalNumber(params.sinceExceptionSeq, "sinceExceptionSeq") ?? void 0,
+            max: optionalNumber(params.max, "max") ?? void 0,
+            requestId: optionalString(params.requestId),
+            relayStatus: core.relay.status()
+          });
+        }
+        case "session.inspectPlan":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return runInspectChallengePlan(core, params);
+        case "session.inspectAudit":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return runInspectAudit(core, params);
+        case "desktop.status":
+          return core.desktopRuntime.status();
+        case "desktop.windows.list":
+          return core.desktopRuntime.listWindows(optionalString(params.reason));
+        case "desktop.window.active":
+          return core.desktopRuntime.activeWindow(optionalString(params.reason));
+        case "desktop.capture.desktop":
+          return core.desktopRuntime.captureDesktop({
+            reason: requireString(params.reason, "reason")
+          });
+        case "desktop.capture.window":
+          return core.desktopRuntime.captureWindow(
+            requireString(params.windowId, "windowId"),
+            { reason: requireString(params.reason, "reason") }
+          );
+        case "desktop.accessibility.snapshot":
+          return core.desktopRuntime.accessibilitySnapshot(
+            requireString(params.reason, "reason"),
+            optionalString(params.windowId)
+          );
+        case "annotate": {
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          const sessionId = requireString(params.sessionId, "sessionId");
+          const stored = optionalBoolean2(params.stored) ?? false;
+          const transport = stored ? "relay" : requireAnnotationTransport(params.transport);
+          if (transport === "relay" && !stored) {
+            const status = await core.manager.status(sessionId);
+            if (status.mode !== "extension") {
+              throw new Error("Relay annotations require extension mode.");
+            }
+          }
+          const url = optionalString(params.url);
+          const targetId = optionalString(params.targetId);
+          const tabId = optionalNumber(params.tabId, "tabId");
+          const screenshotMode = requireScreenshotMode(params.screenshotMode);
+          const debug = optionalBoolean2(params.debug) ?? false;
+          const context = optionalString(params.context);
+          const includeScreenshots = optionalBoolean2(params.includeScreenshots) ?? true;
+          const timeoutMs = optionalNumber(params.timeoutMs, "timeoutMs");
+          return core.annotationManager.requestAnnotation({
+            sessionId,
+            transport,
+            stored,
+            includeScreenshots,
+            targetId,
+            tabId,
+            url,
+            screenshotMode,
+            debug,
+            context,
+            timeoutMs
+          });
+        }
+        case "agent.inbox.enqueue":
+          return core.agentInbox.enqueue({
+            payload: requireAnnotationPayload(params.payload),
+            source: requireAnnotationDispatchSource(params.source),
+            label: optionalString(params.label) ?? "",
+            explicitChatScopeKey: optionalString(params.chatScopeKey) ?? null
+          });
+        case "agent.inbox.peek": {
+          const chatScopeKey = requireString(params.chatScopeKey, "chatScopeKey");
+          return {
+            chatScopeKey,
+            activeScopes: core.agentInbox.listActiveScopes(),
+            entries: core.agentInbox.peekScope(chatScopeKey)
+          };
+        }
+        case "agent.inbox.consume": {
+          const chatScopeKey = requireString(params.chatScopeKey, "chatScopeKey");
+          const entries = core.agentInbox.consumeScope(chatScopeKey);
+          return {
+            chatScopeKey,
+            receiptIds: entries.map((entry) => entry.id),
+            entries
+          };
+        }
+        case "agent.inbox.ack": {
+          const receiptIds = requireStringArray(params.receiptIds, "receiptIds");
+          core.agentInbox.acknowledge(receiptIds);
+          return {
+            ok: true,
+            receiptIds
+          };
+        }
+        case "targets.list":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.listTargets(
+            requireString(params.sessionId, "sessionId"),
+            optionalBoolean2(params.includeUrls) ?? false
+          );
+        case "targets.use":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.useTarget(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.targetId, "targetId")
+          );
+        case "targets.new":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.newTarget(
+            requireString(params.sessionId, "sessionId"),
+            optionalString(params.url)
+          );
+        case "targets.close":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          await core.manager.closeTarget(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.targetId, "targetId")
+          );
+          return { ok: true };
+        case "page.open":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.page(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.name, "name"),
+            optionalString(params.url)
+          );
+        case "page.list":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.listPages(requireString(params.sessionId, "sessionId"));
+        case "page.close":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          await core.manager.closePage(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.name, "name")
+          );
+          return { ok: true };
+        case "nav.goto":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          {
+            const targetId = optionalString(params.targetId);
+            const sessionId = requireString(params.sessionId, "sessionId");
+            return attachBlockerMetaForNavigation(
+              core,
+              sessionId,
+              await core.manager.goto(
+                sessionId,
+                requireString(params.url, "url"),
+                requireWaitUntil(params.waitUntil),
+                optionalNumber(params.timeoutMs, "timeoutMs") ?? 3e4,
+                void 0,
+                targetId
+              )
+            );
+          }
+        case "nav.wait":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          {
+            const targetId = optionalString(params.targetId);
+            const sessionId = requireString(params.sessionId, "sessionId");
+            if (typeof params.ref === "string") {
+              return attachBlockerMetaForNavigation(
+                core,
+                sessionId,
+                await core.manager.waitForRef(
+                  sessionId,
+                  requireString(params.ref, "ref"),
+                  requireState(params.state),
+                  optionalNumber(params.timeoutMs, "timeoutMs") ?? 3e4,
+                  targetId
+                )
+              );
+            }
+            return attachBlockerMetaForNavigation(
+              core,
+              sessionId,
+              await core.manager.waitForLoad(
+                sessionId,
+                requireWaitUntil(params.until),
+                optionalNumber(params.timeoutMs, "timeoutMs") ?? 3e4,
+                targetId
+              )
+            );
+          }
+        case "nav.snapshot":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          {
+            const targetId = optionalString(params.targetId);
+            return core.manager.snapshot(
+              requireString(params.sessionId, "sessionId"),
+              requireSnapshotMode(params.mode),
+              optionalPositiveInteger2(params.maxChars, "maxChars") ?? 16e3,
+              optionalString(params.cursor),
+              targetId
+            );
+          }
+        case "nav.review":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return buildBrowserReviewResult({
+            manager: core.manager,
+            sessionId: requireString(params.sessionId, "sessionId"),
+            targetId: optionalString(params.targetId),
+            maxChars: optionalPositiveInteger2(params.maxChars, "maxChars") ?? core.config.snapshot.maxChars,
+            cursor: optionalString(params.cursor)
+          });
+        case "nav.reviewDesktop":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return runReviewDesktop(core, params);
+        case "interact.click":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.click(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "interact.hover":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.hover(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "interact.press":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.press(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.key, "key"),
+            optionalString(params.ref),
+            optionalString(params.targetId)
+          );
+        case "interact.check":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.check(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "interact.uncheck":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.uncheck(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "interact.type":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.type(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            requireString(params.text, "text"),
+            optionalBoolean2(params.clear) ?? false,
+            optionalBoolean2(params.submit) ?? false,
+            optionalString(params.targetId)
+          );
+        case "interact.select":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.select(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            requireStringArray(params.values, "values"),
+            optionalString(params.targetId)
+          );
+        case "interact.upload":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.upload(
+            requireString(params.sessionId, "sessionId"),
+            {
+              ref: requireString(params.ref, "ref"),
+              files: requireStringArray(params.files, "files"),
+              ...typeof params.targetId === "string" ? { targetId: params.targetId } : {}
+            }
+          );
+        case "interact.scroll":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.scroll(
+            requireString(params.sessionId, "sessionId"),
+            optionalNumber(params.dy, "dy") ?? 0,
+            optionalString(params.ref),
+            optionalString(params.targetId)
+          );
+        case "interact.scrollIntoView":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.scrollIntoView(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "pointer.move":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.pointerMove(
+            requireString(params.sessionId, "sessionId"),
+            requireFiniteNumber(params.x, "x"),
+            requireFiniteNumber(params.y, "y"),
+            optionalString(params.targetId),
+            optionalNumber(params.steps, "steps")
+          );
+        case "pointer.down":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.pointerDown(
+            requireString(params.sessionId, "sessionId"),
+            requireFiniteNumber(params.x, "x"),
+            requireFiniteNumber(params.y, "y"),
+            optionalString(params.targetId),
+            optionalPointerButton(params.button),
+            optionalNumber(params.clickCount, "clickCount") ?? 1
+          );
+        case "pointer.up":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.pointerUp(
+            requireString(params.sessionId, "sessionId"),
+            requireFiniteNumber(params.x, "x"),
+            requireFiniteNumber(params.y, "y"),
+            optionalString(params.targetId),
+            optionalPointerButton(params.button),
+            optionalNumber(params.clickCount, "clickCount") ?? 1
+          );
+        case "pointer.drag":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.drag(
+            requireString(params.sessionId, "sessionId"),
+            requirePointerPoint(params.from, "from"),
+            requirePointerPoint(params.to, "to"),
+            optionalString(params.targetId),
+            optionalNumber(params.steps, "steps")
+          );
+        case "dom.getHtml":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.domGetHtml(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalPositiveInteger2(params.maxChars, "maxChars") ?? 8e3,
+            optionalString(params.targetId)
+          );
+        case "dom.getText":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.domGetText(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalPositiveInteger2(params.maxChars, "maxChars") ?? 8e3,
+            optionalString(params.targetId)
+          );
+        case "dom.getAttr":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.domGetAttr(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            requireString(params.name, "name"),
+            optionalString(params.targetId)
+          );
+        case "dom.getValue":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.domGetValue(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "dom.isVisible":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.domIsVisible(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "dom.isEnabled":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.domIsEnabled(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "dom.isChecked":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.domIsChecked(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "export.clonePage":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.clonePage(
+            requireString(params.sessionId, "sessionId"),
+            optionalString(params.targetId)
+          );
+        case "export.clonePageHtml":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          if (typeof core.manager.clonePageHtmlWithOptions !== "function") {
+            throw new Error("clonePageHtmlWithOptions unavailable in this execution lane.");
+          }
+          {
+            const maxNodes = optionalPositiveInteger2(params.maxNodes, "maxNodes");
+            return core.manager.clonePageHtmlWithOptions(
+              requireString(params.sessionId, "sessionId"),
+              optionalString(params.targetId),
+              {
+                ...typeof maxNodes === "number" ? { maxNodes } : {},
+                ...typeof params.inlineStyles === "boolean" ? { inlineStyles: params.inlineStyles } : {}
+              }
+            );
+          }
+        case "export.cloneComponent":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.cloneComponent(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.ref, "ref"),
+            optionalString(params.targetId)
+          );
+        case "devtools.perf":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.perfMetrics(
+            requireString(params.sessionId, "sessionId"),
+            optionalString(params.targetId)
+          );
+        case "page.screenshot":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.screenshot(
+            requireString(params.sessionId, "sessionId"),
+            {
+              ...typeof params.path === "string" ? { path: params.path } : {},
+              ...typeof params.targetId === "string" ? { targetId: params.targetId } : {},
+              ...typeof params.ref === "string" ? { ref: params.ref } : {},
+              ...params.fullPage === true ? { fullPage: true } : {}
+            }
+          );
+        case "page.screencast.start":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          const screencastOwnerClientId = requireClientId(params);
+          const screencast = await core.manager.startScreencast(
+            requireString(params.sessionId, "sessionId"),
+            {
+              targetId: optionalString(params.targetId),
+              outputDir: optionalString(params.outputDir),
+              intervalMs: optionalNumber(params.intervalMs, "intervalMs") ?? void 0,
+              maxFrames: optionalNumber(params.maxFrames, "maxFrames") ?? void 0
+            }
+          );
+          registerScreencastOwner(screencast.sessionId, screencast.screencastId, screencastOwnerClientId);
+          core.manager.monitorScreencastCompletion?.(screencast.screencastId, () => {
+            completeScreencastOwner(screencast.screencastId);
+          });
+          return screencast;
+        case "page.screencast.stop":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          const screencastResult = await core.manager.stopScreencast(
+            requireString(params.sessionId, "sessionId"),
+            requireString(params.screencastId, "screencastId")
+          );
+          completeScreencastOwner(screencastResult.screencastId);
+          return screencastResult;
+        case "page.dialog":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.dialog(
+            requireString(params.sessionId, "sessionId"),
+            {
+              ...typeof params.targetId === "string" ? { targetId: params.targetId } : {},
+              ...typeof params.action === "string" ? { action: requireDialogAction(params.action) } : {},
+              ...typeof params.promptText === "string" ? { promptText: params.promptText } : {}
+            }
+          );
+        case "devtools.consolePoll":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.consolePoll(
+            requireString(params.sessionId, "sessionId"),
+            optionalNonNegativeInteger(params.sinceSeq, "sinceSeq"),
+            optionalPositiveInteger2(params.max, "max") ?? 50
+          );
+        case "devtools.networkPoll":
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          return core.manager.networkPoll(
+            requireString(params.sessionId, "sessionId"),
+            optionalNonNegativeInteger(params.sinceSeq, "sinceSeq"),
+            optionalPositiveInteger2(params.max, "max") ?? 50
+          );
+        case "devtools.debugTraceSnapshot": {
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          const sessionId = requireString(params.sessionId, "sessionId");
+          const manager = core.manager;
+          const max = optionalNumber(params.max, "max") ?? 50;
+          const requestId = optionalString(params.requestId);
+          const sinceConsoleSeq = optionalNumber(params.sinceConsoleSeq, "sinceConsoleSeq");
+          const sinceNetworkSeq = optionalNumber(params.sinceNetworkSeq, "sinceNetworkSeq");
+          const sinceExceptionSeq = optionalNumber(params.sinceExceptionSeq, "sinceExceptionSeq");
+          if (typeof manager.debugTraceSnapshot === "function") {
+            return manager.debugTraceSnapshot(sessionId, {
+              sinceConsoleSeq,
+              sinceNetworkSeq,
+              sinceExceptionSeq,
+              max,
+              requestId
+            });
+          }
+          const [page, consoleChannel, networkChannel] = await Promise.all([
+            core.manager.status(sessionId),
+            core.manager.consolePoll(sessionId, sinceConsoleSeq, max),
+            core.manager.networkPoll(sessionId, sinceNetworkSeq, max)
+          ]);
+          const exceptionChannel = typeof manager.exceptionPoll === "function" ? await manager.exceptionPoll(sessionId, sinceExceptionSeq, max) : { events: [], nextSeq: sinceExceptionSeq ?? 0 };
+          const fallbackResult = {
+            requestId: requestId ?? randomUUID3(),
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            page,
+            channels: {
+              console: consoleChannel,
+              network: networkChannel,
+              exception: exceptionChannel
+            }
+          };
+          return attachBlockerMetaForTrace(core, fallbackResult);
+        }
+        case "session.cookieImport": {
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          const sessionId = requireString(params.sessionId, "sessionId");
+          const manager = core.manager;
+          const cookies = requireCookieArray(params.cookies, "cookies");
+          const strict = optionalBoolean2(params.strict) ?? true;
+          const requestId = optionalString(params.requestId) ?? randomUUID3();
+          if (typeof manager.cookieImport === "function") {
+            return manager.cookieImport(sessionId, cookies, strict, requestId);
+          }
+          const normalized = [];
+          const rejected = [];
+          cookies.forEach((cookie, index) => {
+            const validation = validateCookieRecord(cookie);
+            if (!validation.valid) {
+              rejected.push({ index, reason: validation.reason });
+              return;
+            }
+            normalized.push(validation.cookie);
+          });
+          if (strict && rejected.length > 0) {
+            throw new Error(`Cookie import rejected ${rejected.length} entries.`);
+          }
+          if (normalized.length > 0) {
+            const targetId = optionalString(params.targetId);
+            await core.manager.withPage(sessionId, targetId ?? null, async (page) => {
+              await page.context().addCookies(normalized);
+              return void 0;
+            });
+          }
+          return {
+            requestId,
+            imported: normalized.length,
+            rejected
+          };
+        }
+        case "session.cookieList": {
+          await authorizeSessionCommand(core, params, request.name, bindingId);
+          const sessionId = requireString(params.sessionId, "sessionId");
+          const manager = core.manager;
+          const urls = requireOptionalCookieUrlArray(params.urls, "urls");
+          const requestId = optionalString(params.requestId) ?? randomUUID3();
+          if (typeof manager.cookieList === "function") {
+            return manager.cookieList(sessionId, urls, requestId);
+          }
+          const targetId = optionalString(params.targetId);
+          const cookies = await core.manager.withPage(
+            sessionId,
+            targetId ?? null,
+            async (page) => {
+              const listed = urls ? await page.context().cookies(urls) : await page.context().cookies();
+              return listed.map((cookie) => ({
+                name: cookie.name,
+                value: cookie.value,
+                domain: cookie.domain,
+                path: cookie.path,
+                expires: cookie.expires,
+                httpOnly: cookie.httpOnly,
+                secure: cookie.secure,
+                ...cookie.sameSite ? { sameSite: cookie.sameSite } : {}
+              }));
+            }
+          );
+          return {
+            requestId,
+            cookies,
+            count: cookies.length
+          };
+        }
+        case "macro.resolve": {
+          const execute = optionalBoolean2(params.execute) ?? false;
+          const browserMode = optionalWorkflowBrowserMode(params.browserMode);
+          const useCookies = optionalBoolean2(params.useCookies);
+          const challengeAutomationMode = optionalChallengeAutomationMode(params.challengeAutomationMode);
+          const cookiePolicyOverride = optionalCookiePolicy(params.cookiePolicyOverride);
+          if (!execute && browserMode) {
+            throw new Error("browserMode requires execute=true for macro resolution");
+          }
+          if (!execute && typeof useCookies === "boolean") {
+            throw new Error("useCookies requires execute=true for macro resolution");
+          }
+          if (!execute && challengeAutomationMode) {
+            throw new Error("challengeAutomationMode requires execute=true for macro resolution");
+          }
+          if (!execute && cookiePolicyOverride) {
+            throw new Error("cookiePolicyOverride requires execute=true for macro resolution");
+          }
+          return resolveMacroExpression(
+            {
+              expression: requireString(params.expression, "expression"),
+              defaultProvider: optionalString(params.defaultProvider),
+              includeCatalog: optionalBoolean2(params.includeCatalog) ?? false,
+              execute,
+              timeoutMs: optionalNumber(params.timeoutMs, "timeoutMs"),
+              browserMode,
+              useCookies,
+              challengeAutomationMode,
+              cookiePolicyOverride
+            },
+            core.config,
+            core.manager,
+            core.browserFallbackPort,
+            core.providerRuntime
+          );
+        }
+        case "research.run":
+          return runResearchWorkflow(
+            createDaemonWorkflowRuntime(core),
+            {
+              topic: requireString(params.topic, "topic"),
+              days: optionalNumber(params.days, "days"),
+              from: optionalString(params.from),
+              to: optionalString(params.to),
+              sourceSelection: optionalProviderSelection(params.sourceSelection),
+              sources: optionalProviderSources(params.sources),
+              mode: optionalRenderMode(params.mode) ?? "compact",
+              includeEngagement: optionalBoolean2(params.includeEngagement),
+              limitPerSource: optionalNumber(params.limitPerSource, "limitPerSource"),
+              timeoutMs: optionalNumber(params.timeoutMs, "timeoutMs"),
+              outputDir: optionalString(params.outputDir),
+              ttlHours: optionalNumber(params.ttlHours, "ttlHours"),
+              browserMode: optionalWorkflowBrowserMode(params.browserMode),
+              useCookies: optionalBoolean2(params.useCookies),
+              challengeAutomationMode: optionalChallengeAutomationMode(params.challengeAutomationMode),
+              cookiePolicyOverride: optionalCookiePolicy(params.cookiePolicyOverride)
+            }
+          );
+        case "shopping.run":
+          return runShoppingWorkflow(
+            createDaemonWorkflowRuntime(core),
+            {
+              query: requireString(params.query, "query"),
+              providers: optionalStringArray2(params.providers),
+              budget: optionalNumber(params.budget, "budget"),
+              region: optionalString(params.region),
+              browserMode: optionalWorkflowBrowserMode(params.browserMode),
+              sort: optionalShoppingSort(params.sort),
+              mode: optionalRenderMode(params.mode) ?? "compact",
+              timeoutMs: optionalNumber(params.timeoutMs, "timeoutMs"),
+              outputDir: optionalString(params.outputDir),
+              ttlHours: optionalNumber(params.ttlHours, "ttlHours"),
+              useCookies: optionalBoolean2(params.useCookies),
+              challengeAutomationMode: optionalChallengeAutomationMode(params.challengeAutomationMode),
+              cookiePolicyOverride: optionalCookiePolicy(params.cookiePolicyOverride)
+            }
+          );
+        case "inspiredesign.run": {
+          const inspiredesignTimeoutMs = optionalNumber(params.timeoutMs, "timeoutMs");
+          return runInspiredesignWorkflow(
+            createDaemonWorkflowRuntime(core),
+            {
+              brief: requireString(params.brief, "brief"),
+              urls: optionalStringArray2(params.urls),
+              captureMode: optionalInspiredesignCaptureMode(params.captureMode),
+              includePrototypeGuidance: optionalBoolean2(params.includePrototypeGuidance),
+              mode: optionalRenderMode(params.mode) ?? "compact",
+              timeoutMs: inspiredesignTimeoutMs,
+              outputDir: optionalString(params.outputDir),
+              ttlHours: optionalNumber(params.ttlHours, "ttlHours"),
+              browserMode: optionalWorkflowBrowserMode(params.browserMode),
+              useCookies: optionalBoolean2(params.useCookies),
+              challengeAutomationMode: optionalChallengeAutomationMode(params.challengeAutomationMode),
+              cookiePolicyOverride: optionalCookiePolicy(params.cookiePolicyOverride)
+            },
+            {
+              captureReference: async (url, options) => captureInspiredesignReferenceFromManager(core.manager, url, {
+                ...options,
+                cookieSource: core.config.providers?.cookieSource
+              })
+            }
+          );
+        }
+        case "product.video.run": {
+          const productVideoTimeoutMs = optionalNumber(params.timeoutMs, "timeoutMs");
+          return runProductVideoWorkflow(
+            createDaemonWorkflowRuntime(core),
+            {
+              product_url: optionalString(params.product_url),
+              product_name: optionalString(params.product_name),
+              provider_hint: optionalString(params.provider_hint),
+              include_screenshots: optionalBoolean2(params.include_screenshots),
+              include_all_images: optionalBoolean2(params.include_all_images),
+              include_copy: optionalBoolean2(params.include_copy),
+              output_dir: optionalString(params.output_dir),
+              ttl_hours: optionalNumber(params.ttl_hours, "ttl_hours"),
+              timeoutMs: productVideoTimeoutMs,
+              browserMode: optionalWorkflowBrowserMode(params.browserMode),
+              useCookies: optionalBoolean2(params.useCookies),
+              challengeAutomationMode: optionalChallengeAutomationMode(params.challengeAutomationMode),
+              cookiePolicyOverride: optionalCookiePolicy(params.cookiePolicyOverride)
+            },
+            {
+              captureScreenshot: async (url, timeoutMs) => {
+                const captureTimeoutMs = Math.max(1, Math.min(timeoutMs ?? 3e4, 3e4));
+                const session = await core.manager.launch({
+                  headless: true,
+                  startUrl: "about:blank",
+                  // Capture sessions are ephemeral; avoid persisted profile lock contention.
+                  persistProfile: false
+                });
+                try {
+                  await core.manager.goto(session.sessionId, url, "load", captureTimeoutMs);
+                  const screenshot = await Promise.race([
+                    core.manager.screenshot(session.sessionId),
+                    new Promise((resolve2) => {
+                      setTimeout(() => resolve2(null), captureTimeoutMs);
+                    })
+                  ]);
+                  if (!screenshot || typeof screenshot.base64 !== "string" || screenshot.base64.length === 0) return null;
+                  return Buffer.from(screenshot.base64, "base64");
+                } catch {
+                  return null;
+                } finally {
+                  await core.manager.disconnect(session.sessionId, true).catch(() => {
+                  });
+                }
+              }
+            }
+          );
+        }
+        default:
+          throw new Error(`Unknown daemon command: ${request.name}`);
+      }
+    })();
+  } catch (error) {
+    throw coerceDaemonSessionError(params, error);
+  }
+}
+async function launchWithRelay(core, params, clientId, bindingId) {
+  let relayStatus = core.relay.status();
+  const extensionLegacy = optionalBoolean2(params.extensionLegacy) ?? false;
+  let relayUrl = extensionLegacy ? core.relay.getCdpUrl() : core.relay.getOpsUrl?.() ?? null;
+  const relayPort = core.config.relayPort;
+  const noExtension = optionalBoolean2(params.noExtension) ?? false;
+  const extensionOnly = optionalBoolean2(params.extensionOnly) ?? false;
+  const waitForExtension = optionalBoolean2(params.waitForExtension) ?? false;
+  const headlessExplicit = optionalBoolean2(params.headless) === true;
+  if (headlessExplicit && !noExtension) {
+    throw unsupportedModeError(
+      "Extension mode does not support headless launches. Use --no-extension --headless for managed mode."
+    );
+  }
+  const managedExplicit = Boolean(noExtension || headlessExplicit);
+  const managedHeadless = headlessExplicit ? true : false;
+  const waitTimeoutMs = clampWaitTimeout(optionalNumber(params.waitTimeoutMs, "waitTimeoutMs") ?? 3e4);
+  if (!managedExplicit && extensionLegacy) {
+    requireBinding(clientId, bindingId);
+  }
+  if (waitForExtension && !managedExplicit) {
+    const observedPort2 = resolveObservedPort(relayStatus, relayPort);
+    const connected = await waitForRelayHandshake(core.relay, observedPort2, waitTimeoutMs);
+    if (connected) {
+      relayStatus = core.relay.status();
+      relayUrl = extensionLegacy ? core.relay.getCdpUrl() ?? relayUrl : core.relay.getOpsUrl?.() ?? relayUrl;
+    }
+  }
+  const observedPort = resolveObservedPort(relayStatus, relayPort);
+  const shouldFetchObserved = !managedExplicit && (!relayUrl || !relayStatus.extensionHandshakeComplete);
+  const observedStatus = shouldFetchObserved ? await fetchRelayObservedStatus(observedPort) : null;
+  const matchingObservedStatus = getMatchingObservedRelayStatus(relayStatus, observedStatus);
+  if (!relayUrl) {
+    const fallbackPort = isValidPort(observedStatus?.port) ? observedStatus?.port : observedPort;
+    relayUrl = fallbackPort ? buildLoopbackSessionRelayEndpoint(fallbackPort, { extensionLegacy }) : null;
+  }
+  const extensionReady = Boolean(
+    relayUrl && (relayStatus.extensionHandshakeComplete || matchingObservedStatus?.extensionHandshakeComplete)
+  );
+  const extensionSocketConnected = Boolean(
+    relayStatus.extensionConnected || matchingObservedStatus?.extensionConnected
+  );
+  const observedInstanceMismatch = Boolean(
+    observedStatus && observedStatus.instanceId !== relayStatus.instanceId && (observedStatus.extensionConnected || observedStatus.extensionHandshakeComplete)
+  );
+  const handshakePending = Boolean(relayUrl && extensionSocketConnected && !extensionReady);
+  const diagnostics = observedStatus ? `Diagnostics: relayPort=${observedPort ?? "?"} instance=${observedStatus.instanceId.slice(0, 8)} ext=${observedStatus.extensionConnected} handshake=${observedStatus.extensionHandshakeComplete} ops=${observedStatus.opsConnected} cdp=${observedStatus.cdpConnected}` : null;
+  const missingReason = observedInstanceMismatch ? diagnostics ? `Extension not connected to the expected relay instance. ${diagnostics}` : "Extension not connected to the expected relay instance." : handshakePending ? diagnostics ? `Extension websocket connected but handshake incomplete. Re-establish a clean daemon-extension handshake. ${diagnostics}` : "Extension websocket connected but handshake incomplete. Re-establish a clean daemon-extension handshake." : diagnostics ? `Extension not connected. ${diagnostics}` : "Extension not connected.";
+  if (extensionOnly && !extensionReady) {
+    throw new Error(buildExtensionMissingMessage(missingReason));
+  }
+  if (!managedExplicit) {
+    if (!extensionReady || !relayUrl) {
+      throw new Error(buildExtensionMissingMessage(missingReason));
+    }
+    try {
+      const startUrl = optionalString(params.startUrl);
+      const result = startUrl ? await core.manager.connectRelay(relayUrl, { startUrl }) : await core.manager.connectRelay(relayUrl);
+      const leaseId = extractLeaseId(result);
+      if (result.mode === "extension" && !extensionLegacy && !leaseId) {
+        throw new Error("[invalid_session] Extension relay session missing leaseId.");
+      }
+      if (result.mode === "extension" && leaseId) {
+        registerSessionLease(result.sessionId, leaseId, clientId);
+      }
+      return { ...result, warnings: result.warnings ?? [], ...leaseId ? { leaseId } : {} };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const unauthorized = message.toLowerCase().includes("unauthorized") || message.includes("401");
+      const relayLabel = extensionLegacy ? "/cdp" : "/ops";
+      const reason = unauthorized ? `Extension relay connection failed: relay ${relayLabel} unauthorized (token mismatch).` : `Extension relay connection failed: ${message}`;
+      throw new Error(buildExtensionMissingMessage(reason));
+    }
+  }
+  try {
+    const result = await core.manager.launch({
+      profile: optionalString(params.profile),
+      headless: managedHeadless,
+      startUrl: optionalString(params.startUrl),
+      chromePath: optionalString(params.chromePath),
+      flags: optionalStringArray2(params.flags),
+      persistProfile: optionalBoolean2(params.persistProfile)
+    });
+    return { ...result, warnings: result.warnings ?? [] };
+  } catch (error) {
+    throw new Error(buildManagedFailureMessage(error));
+  }
+}
+async function connectWithRelayRouting(core, params, clientId, bindingId) {
+  const wsEndpoint = optionalString(params.wsEndpoint);
+  const extensionLegacy = optionalBoolean2(params.extensionLegacy) ?? false;
+  const relayUrl = extensionLegacy ? core.relay.getCdpUrl() : core.relay.getOpsUrl?.() ?? null;
+  const parsedRelayEndpoint = classifySessionRelayEndpoint(wsEndpoint);
+  const resolvedRelayEndpoint = parsedRelayEndpoint ? resolveSessionRelayRoute(parsedRelayEndpoint, { extensionLegacy }) : null;
+  if (resolvedRelayEndpoint && "code" in resolvedRelayEndpoint) {
+    throw new Error("Legacy extension relay (/cdp) requires --extension-legacy.");
+  }
+  const relayEndpoint = relayUrl && wsEndpoint === relayUrl ? relayUrl : resolvedRelayEndpoint?.normalizedEndpoint ?? null;
+  const hasExplicitCdp = Boolean(wsEndpoint || params.host || params.port);
+  const headlessExplicit = optionalBoolean2(params.headless) === true;
+  if (headlessExplicit && !hasExplicitCdp) {
+    throw unsupportedModeError(
+      "Extension mode does not support headless connect routing. Use launch --no-extension --headless or connect to an explicit CDP endpoint."
+    );
+  }
+  if (relayEndpoint || !hasExplicitCdp && relayUrl) {
+    if (headlessExplicit) {
+      throw unsupportedModeError(
+        "Extension mode does not support headless connect routing. Use launch --no-extension --headless or connect to an explicit CDP endpoint."
+      );
+    }
+    if (extensionLegacy) {
+      requireBinding(clientId, bindingId);
+    }
+    const startUrl = optionalString(params.startUrl);
+    const result = startUrl ? await core.manager.connectRelay(relayEndpoint ?? relayUrl ?? "", { startUrl }) : await core.manager.connectRelay(relayEndpoint ?? relayUrl ?? "");
+    const leaseId = extractLeaseId(result);
+    if (result.mode === "extension" && !extensionLegacy && !leaseId) {
+      throw new Error("[invalid_session] Extension relay session missing leaseId.");
+    }
+    if (result.mode === "extension" && leaseId) {
+      registerSessionLease(result.sessionId, leaseId, clientId);
+    }
+    return { ...result, ...leaseId ? { leaseId } : {} };
+  }
+  if (!hasExplicitCdp) {
+    throw new Error("Extension relay not available. Connect the extension or pass --cdp-port/--ws-endpoint.");
+  }
+  return core.manager.connect({
+    wsEndpoint,
+    host: optionalString(params.host),
+    port: optionalNumber(params.port, "port"),
+    startUrl: optionalString(params.startUrl)
+  });
+}
+async function disconnectSession(core, params, clientId, bindingId) {
+  const sessionId = requireString(params.sessionId, "sessionId");
+  let status = null;
+  try {
+    status = await core.manager.status(sessionId);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    if (isIgnorableDisconnectStatusError(message)) {
+      const lease = getSessionLease(sessionId);
+      if (lease) {
+        requireSessionLease(sessionId, clientId, optionalString(params.leaseId));
+      } else if (bindingId) {
+        requireBinding(clientId, bindingId);
+      }
+      releaseSessionLease(sessionId);
+      if (bindingId) {
+        releaseRelay(clientId, bindingId);
+        return { ok: true, bindingReleased: true };
+      }
+      return { ok: true };
+    }
+    throw error;
+  }
+  if (status.mode === "extension") {
+    const lease = getSessionLease(sessionId);
+    if (lease) {
+      requireSessionLease(sessionId, clientId, optionalString(params.leaseId));
+    } else {
+      requireBinding(clientId, bindingId);
+    }
+  }
+  await core.manager.disconnect(sessionId, optionalBoolean2(params.closeBrowser) ?? false);
+  releaseSessionLease(sessionId);
+  if (status.mode === "extension" && bindingId) {
+    releaseRelay(clientId, bindingId);
+    return { ok: true, bindingReleased: true };
+  }
+  return { ok: true };
+}
+function requireSessionInspectorHandle(core) {
+  const inspector = core.manager.createSessionInspector?.();
+  if (!inspector) {
+    throw new Error("Session inspector is unavailable for the current runtime.");
+  }
+  return inspector;
+}
+function readChallengeAutomationMode(params) {
+  return optionalChallengeAutomationMode(params.challengeAutomationMode);
+}
+async function runReviewDesktop(core, params) {
+  return core.automationCoordinator.reviewDesktop({
+    browserSessionId: requireString(params.sessionId, "sessionId"),
+    targetId: optionalString(params.targetId),
+    reason: optionalString(params.reason),
+    maxChars: optionalNumber(params.maxChars, "maxChars"),
+    cursor: optionalString(params.cursor)
+  });
+}
+async function runInspectChallengePlan(core, params) {
+  return core.automationCoordinator.inspectChallengePlan({
+    browserSessionId: requireString(params.sessionId, "sessionId"),
+    targetId: optionalString(params.targetId),
+    runMode: readChallengeAutomationMode(params)
+  });
+}
+async function runInspectAudit(core, params) {
+  const browserSessionId = requireString(params.sessionId, "sessionId");
+  const targetId = optionalString(params.targetId);
+  const review = await runReviewDesktop(core, params);
+  const challengePlan = await core.automationCoordinator.inspectChallengePlan({
+    browserSessionId,
+    targetId,
+    runMode: readChallengeAutomationMode(params)
+  });
+  return buildCorrelatedAuditBundle({
+    handle: requireSessionInspectorHandle(core),
+    browserSessionId,
+    targetId,
+    observation: review.observation,
+    review: review.verification,
+    challengePlan,
+    includeUrls: optionalBoolean2(params.includeUrls) ?? void 0,
+    sinceConsoleSeq: optionalNumber(params.sinceConsoleSeq, "sinceConsoleSeq"),
+    sinceNetworkSeq: optionalNumber(params.sinceNetworkSeq, "sinceNetworkSeq"),
+    sinceExceptionSeq: optionalNumber(params.sinceExceptionSeq, "sinceExceptionSeq"),
+    max: optionalNumber(params.max, "max"),
+    requestId: optionalString(params.requestId),
+    relayStatus: core.relay.status()
+  });
+}
+async function runStatusCapabilities(core, params) {
+  return core.automationCoordinator.statusCapabilities({
+    browserSessionId: optionalString(params.sessionId),
+    targetId: optionalString(params.targetId),
+    runMode: readChallengeAutomationMode(params)
+  });
+}
+async function authorizeSessionCommand(core, params, commandName, bindingId) {
+  const sessionId = optionalString(params.sessionId);
+  if (!sessionId) return;
+  const clientId = requireClientId(params);
+  const lease = getSessionLease(sessionId);
+  if (lease) {
+    requireSessionLease(sessionId, clientId, optionalString(params.leaseId));
+    return;
+  }
+  let status;
+  try {
+    status = await core.manager.status(sessionId);
+  } catch (error) {
+    if (canStopCompletedScreencastWithoutLiveSession(commandName, error)) {
+      requireScreencastOwner(
+        sessionId,
+        requireString(params.screencastId, "screencastId"),
+        clientId
+      );
+      return;
+    }
+    throw error;
+  }
+  if (status.mode !== "extension") {
+    return;
+  }
+  requireBinding(clientId, bindingId);
+}
+function extractLeaseId(result) {
+  if (!result || typeof result !== "object") return void 0;
+  const leaseId = result.leaseId;
+  return typeof leaseId === "string" ? leaseId : void 0;
+}
+function buildExtensionMissingMessage(reason) {
+  return [
+    reason,
+    "Connect the extension: open the Chrome extension popup and click Connect. If ext=on but handshake=off, click Connect again to re-establish a clean daemon-extension handshake, then retry.",
+    "Tip: If the popup says Connected, it may be connected to a different relay instance/port than the daemon expects.",
+    "Legend: ext=extension websocket, handshake=extension handshake, ops=active /ops client, cdp=active /cdp client, pairing=token required.",
+    "",
+    "Other options (explicit):",
+    "- Managed (headed): npx opendevbrowser launch --no-extension",
+    "- Managed (headless): npx opendevbrowser launch --no-extension --headless",
+    "- Legacy extension relay: npx opendevbrowser launch --extension-legacy",
+    "- CDPConnect (default port): npx opendevbrowser connect --cdp-port 9222",
+    "- CDPConnect (explicit WS): npx opendevbrowser connect --ws-endpoint ws://127.0.0.1:9222/devtools/browser/<id>",
+    "Note: CDPConnect requires Chrome started with --remote-debugging-port=9222."
+  ].join("\n");
+}
+function buildManagedFailureMessage(error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  const normalized = detail.toLowerCase();
+  const profileLocked = normalized.includes("singletonlock") || normalized.includes("processsingleton") || normalized.includes("profile in use") || normalized.includes("already in use") || normalized.includes("user data directory is already in use") || normalized.includes("profile is locked");
+  if (profileLocked) {
+    return [
+      `Managed session failed: ${detail}`,
+      "",
+      "Detected persisted profile lock (another Chrome process is using the same profile).",
+      "Retry options (explicit):",
+      "- Managed with a unique profile: npx opendevbrowser launch --no-extension --profile lock-safe-<timestamp>",
+      "- Managed with a temporary profile: npx opendevbrowser launch --no-extension --persist-profile false",
+      "- CDPConnect (default port): npx opendevbrowser connect --cdp-port 9222",
+      "- CDPConnect (explicit WS): npx opendevbrowser connect --ws-endpoint ws://127.0.0.1:9222/devtools/browser/<id>"
+    ].join("\n");
+  }
+  return [
+    `Managed session failed: ${detail}`,
+    "",
+    "Final option (explicit):",
+    "- CDPConnect (default port): npx opendevbrowser connect --cdp-port 9222",
+    "- CDPConnect (explicit WS): npx opendevbrowser connect --ws-endpoint ws://127.0.0.1:9222/devtools/browser/<id>"
+  ].join("\n");
+}
+function unsupportedModeError(message) {
+  return new Error(`[unsupported_mode] ${message}`);
+}
+function coerceDaemonSessionError(params, error) {
+  const sessionId = optionalString(params.sessionId);
+  const clientId = optionalString(params.clientId);
+  const baseError = error instanceof Error ? error : new Error(String(error ?? ""));
+  if (!sessionId || !clientId) {
+    return baseError;
+  }
+  if (!isStaleExtensionSessionError(baseError.message)) {
+    return baseError;
+  }
+  const released = releaseOwnedSessionLease(sessionId, clientId, optionalString(params.leaseId));
+  if (!released) {
+    return baseError;
+  }
+  return new Error([
+    `[relaunch_required] Extension session ${sessionId} is no longer valid.`,
+    "Relaunch the extension-backed session and retry the command.",
+    `Previous error: ${baseError.message}`
+  ].join(" "));
+}
+function isIgnorableDisconnectStatusError(message) {
+  return message.includes("[invalid_session]") || message.includes("Unknown ops session") || message.includes("Ops client not connected");
+}
+function canStopCompletedScreencastWithoutLiveSession(commandName, error) {
+  if (commandName !== "page.screencast.stop") {
+    return false;
+  }
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return isIgnorableDisconnectStatusError(message);
+}
+function isStaleExtensionSessionError(message) {
+  return message.includes("[invalid_session]") || message.includes("Unknown sessionId:") || message.includes("Unknown ops session") || message.includes("[not_owner]") || message.includes("Client does not own session") || message.includes("Lease does not match session owner");
+}
+async function attachBlockerMetaForNavigation(core, sessionId, result) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    return result;
+  }
+  const record = result;
+  const existingMeta = !Array.isArray(record.meta) && typeof record.meta === "object" && record.meta !== null ? record.meta : void 0;
+  if (existingMeta && typeof existingMeta.blockerState === "string") {
+    return result;
+  }
+  const fallbackStatus = await core.manager.status(sessionId);
+  let networkEvents = { events: [] };
+  try {
+    const polled = await core.manager.networkPoll(
+      sessionId,
+      void 0,
+      core.config.blockerArtifactCaps.maxNetworkEvents
+    );
+    if (polled && Array.isArray(polled.events)) {
+      networkEvents = { events: polled.events };
+    }
+  } catch {
+  }
+  const blocker = classifyBlockerSignal({
+    source: "navigation",
+    url: typeof record.url === "string" ? record.url : fallbackStatus.url,
+    finalUrl: typeof record.finalUrl === "string" ? record.finalUrl : fallbackStatus.url,
+    title: fallbackStatus.title,
+    status: typeof record.status === "number" ? record.status : findLatestStatus(networkEvents.events),
+    networkHosts: extractHosts(networkEvents.events),
+    threshold: core.config.blockerDetectionThreshold,
+    promptGuardEnabled: core.config.security.promptInjectionGuard?.enabled ?? true
+  });
+  return {
+    ...record,
+    meta: {
+      ...existingMeta ?? {},
+      blockerState: blocker ? "active" : "clear",
+      ...blocker ? { blocker } : {}
+    }
+  };
+}
+function attachBlockerMetaForTrace(core, result) {
+  const blocker = classifyBlockerSignal({
+    source: "network",
+    url: result.page.url,
+    finalUrl: result.page.url,
+    title: result.page.title,
+    status: findLatestStatus(result.channels.network.events),
+    networkHosts: extractHosts(result.channels.network.events),
+    traceRequestId: result.requestId,
+    threshold: core.config.blockerDetectionThreshold,
+    promptGuardEnabled: core.config.security.promptInjectionGuard?.enabled ?? true
+  });
+  const blockerArtifacts = blocker ? buildBlockerArtifacts({
+    networkEvents: result.channels.network.events,
+    consoleEvents: result.channels.console.events,
+    exceptionEvents: result.channels.exception.events,
+    promptGuardEnabled: core.config.security.promptInjectionGuard?.enabled ?? true,
+    caps: core.config.blockerArtifactCaps
+  }) : void 0;
+  return {
+    ...result,
+    meta: {
+      blockerState: blocker ? "active" : "clear",
+      ...blocker ? { blocker } : {},
+      ...blockerArtifacts ? { blockerArtifacts } : {}
+    }
+  };
+}
+function findLatestStatus(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const status = events[index]?.status;
+    if (typeof status === "number") return status;
+  }
+  return void 0;
+}
+function extractHosts(events) {
+  const hosts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (typeof event.url !== "string") continue;
+    try {
+      const host = new URL(event.url).hostname.toLowerCase();
+      if (!host || seen.has(host)) continue;
+      seen.add(host);
+      hosts.push(host);
+    } catch {
+    }
+  }
+  return hosts;
+}
+function requireString(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`Missing ${label}`);
+  }
+  return value;
+}
+function requireRecord(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid ${label}`);
+  }
+  return value;
+}
+function requireClientId(params) {
+  return requireString(params.clientId, "clientId");
+}
+function requireStringArray(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`Invalid ${label}`);
+  }
+  return value;
+}
+function requireDialogAction(value) {
+  if (value === "status" || value === "accept" || value === "dismiss") {
+    return value;
+  }
+  throw new Error("Invalid action");
+}
+function requireCookieArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid ${label}`);
+  }
+  const parsed = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`Invalid ${label}`);
+    }
+    const cookie = entry;
+    if (typeof cookie.name !== "string" || typeof cookie.value !== "string") {
+      throw new Error(`Invalid ${label}`);
+    }
+    if (typeof cookie.sameSite !== "undefined" && cookie.sameSite !== "Strict" && cookie.sameSite !== "Lax" && cookie.sameSite !== "None") {
+      throw new Error(`Invalid ${label}`);
+    }
+    parsed.push({
+      name: cookie.name,
+      value: cookie.value,
+      ...typeof cookie.url === "string" ? { url: cookie.url } : {},
+      ...typeof cookie.domain === "string" ? { domain: cookie.domain } : {},
+      ...typeof cookie.path === "string" ? { path: cookie.path } : {},
+      ...typeof cookie.expires === "number" ? { expires: cookie.expires } : {},
+      ...typeof cookie.httpOnly === "boolean" ? { httpOnly: cookie.httpOnly } : {},
+      ...typeof cookie.secure === "boolean" ? { secure: cookie.secure } : {},
+      ...cookie.sameSite ? { sameSite: cookie.sameSite } : {}
+    });
+  }
+  return parsed;
+}
+function requireOptionalCookieUrlArray(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid ${label}`);
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "string") {
+      throw new Error(`Invalid ${label}`);
+    }
+    const trimmed = entry.trim();
+    if (!trimmed) {
+      throw new Error(`Invalid ${label}`);
+    }
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(trimmed);
+    } catch {
+      throw new Error(`Invalid ${label}`);
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+      throw new Error(`Invalid ${label}`);
+    }
+    const normalizedUrl = parsedUrl.toString();
+    if (seen.has(normalizedUrl)) {
+      continue;
+    }
+    seen.add(normalizedUrl);
+    normalized.push(normalizedUrl);
+  }
+  return normalized.length > 0 ? normalized : void 0;
+}
+function validateCookieRecord(cookie) {
+  const name = cookie.name?.trim();
+  if (!name) {
+    return { valid: false, reason: "Cookie name is required.", cookie };
+  }
+  if (!/^[^\s;=]+$/.test(name)) {
+    return { valid: false, reason: `Invalid cookie name: ${cookie.name}.`, cookie };
+  }
+  if (typeof cookie.value !== "string" || /\r|\n|;/.test(cookie.value)) {
+    return { valid: false, reason: `Invalid cookie value for ${name}.`, cookie };
+  }
+  const hasUrl = typeof cookie.url === "string" && cookie.url.trim().length > 0;
+  const hasDomain = typeof cookie.domain === "string" && cookie.domain.trim().length > 0;
+  if (!hasUrl && !hasDomain) {
+    return { valid: false, reason: `Cookie ${name} requires url or domain.`, cookie };
+  }
+  let normalizedUrl;
+  if (hasUrl) {
+    try {
+      const parsedUrl = new URL(cookie.url);
+      if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+        return { valid: false, reason: `Cookie ${name} url must be http(s).`, cookie };
+      }
+      normalizedUrl = parsedUrl.toString();
+    } catch {
+      return { valid: false, reason: `Cookie ${name} has invalid url.`, cookie };
+    }
+  }
+  let normalizedDomain;
+  if (hasDomain) {
+    normalizedDomain = String(cookie.domain).trim().toLowerCase();
+    if (!/^\.?[a-z0-9.-]+$/.test(normalizedDomain) || normalizedDomain.includes("..")) {
+      return { valid: false, reason: `Cookie ${name} has invalid domain.`, cookie };
+    }
+  }
+  const normalizedPath = typeof cookie.path === "string" ? cookie.path.trim() : void 0;
+  if (typeof normalizedPath === "string" && !normalizedPath.startsWith("/")) {
+    return { valid: false, reason: `Cookie ${name} path must start with '/'.`, cookie };
+  }
+  if (typeof cookie.expires !== "undefined") {
+    if (!Number.isFinite(cookie.expires) || cookie.expires < -1) {
+      return { valid: false, reason: `Cookie ${name} has invalid expires.`, cookie };
+    }
+  }
+  if (cookie.sameSite === "None" && cookie.secure !== true) {
+    return { valid: false, reason: `Cookie ${name} with SameSite=None must set secure=true.`, cookie };
+  }
+  const normalizedCookie = {
+    name,
+    value: cookie.value,
+    ...typeof cookie.expires === "number" ? { expires: cookie.expires } : {},
+    ...typeof cookie.httpOnly === "boolean" ? { httpOnly: cookie.httpOnly } : {},
+    ...typeof cookie.secure === "boolean" ? { secure: cookie.secure } : {},
+    ...cookie.sameSite ? { sameSite: cookie.sameSite } : {}
+  };
+  if (normalizedDomain) {
+    normalizedCookie.domain = normalizedDomain;
+    normalizedCookie.path = normalizedPath ?? "/";
+  } else if (normalizedUrl) {
+    normalizedCookie.url = normalizedUrl;
+  }
+  return {
+    valid: true,
+    reason: "",
+    cookie: normalizedCookie
+  };
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function optionalStringArray2(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+function optionalNumber(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  throw new Error(`Invalid ${label}`);
+}
+function optionalBoolean2(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function requireFiniteNumber(value, label) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  throw new Error(`Invalid ${label}`);
+}
+function optionalPositiveInteger2(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  throw new Error(`Invalid ${label}`);
+}
+function optionalNonNegativeInteger(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+    return value;
+  }
+  throw new Error(`Invalid ${label}`);
+}
+function requirePointerPoint(value, label) {
+  const point = requireRecord(value, label);
+  return {
+    x: requireFiniteNumber(point.x, `${label}.x`),
+    y: requireFiniteNumber(point.y, `${label}.y`)
+  };
+}
+function optionalPointerButton(value) {
+  if (value === "middle" || value === "right") {
+    return value;
+  }
+  return "left";
+}
+function optionalRenderMode(value) {
+  if (typeof value === "undefined") return void 0;
+  if (value === "compact" || value === "json" || value === "md" || value === "context" || value === "path") {
+    return value;
+  }
+  throw new Error("Invalid mode");
+}
+function optionalProviderSelection(value) {
+  if (typeof value === "undefined") return void 0;
+  if (value === "auto" || value === "web" || value === "community" || value === "social" || value === "shopping" || value === "all") {
+    return value;
+  }
+  throw new Error("Invalid sourceSelection");
+}
+function optionalProviderSources(value) {
+  if (typeof value === "undefined") return void 0;
+  if (!Array.isArray(value)) {
+    throw new Error("Invalid sources");
+  }
+  const valid = value.every((entry) => entry === "web" || entry === "community" || entry === "social" || entry === "shopping");
+  if (!valid) {
+    throw new Error("Invalid sources");
+  }
+  return value;
+}
+function optionalCookiePolicy(value) {
+  if (typeof value === "undefined") return void 0;
+  if (value === "off" || value === "auto" || value === "required") {
+    return value;
+  }
+  throw new Error("Invalid cookiePolicyOverride");
+}
+function optionalChallengeAutomationMode(value) {
+  if (typeof value === "undefined") return void 0;
+  if (isChallengeAutomationMode(value)) {
+    return value;
+  }
+  throw new Error("Invalid challengeAutomationMode");
+}
+function optionalShoppingSort(value) {
+  if (typeof value === "undefined") return void 0;
+  if (value === "best_deal" || value === "lowest_price" || value === "highest_rating" || value === "fastest_shipping") {
+    return value;
+  }
+  throw new Error("Invalid shopping sort");
+}
+function optionalWorkflowBrowserMode(value) {
+  if (typeof value === "undefined") return void 0;
+  if (value === "auto" || value === "extension" || value === "managed") {
+    return value;
+  }
+  throw new Error("Invalid browserMode");
+}
+function optionalInspiredesignCaptureMode(value) {
+  if (typeof value === "undefined") return void 0;
+  if (value === "off" || value === "deep") {
+    return value;
+  }
+  throw new Error("Invalid captureMode");
+}
+function requireWaitUntil(value) {
+  if (value === "domcontentloaded" || value === "load" || value === "networkidle") {
+    return value;
+  }
+  return "load";
+}
+function requireSnapshotMode(value) {
+  if (value === "actionables") return "actionables";
+  return "outline";
+}
+function requireScreenshotMode(value) {
+  if (value === "visible" || value === "full" || value === "none") {
+    return value;
+  }
+  return "visible";
+}
+function requireAnnotationTransport(value) {
+  if (value === "auto" || value === "direct" || value === "relay") {
+    return value;
+  }
+  if (typeof value === "undefined") {
+    return "auto";
+  }
+  throw new Error("Invalid transport");
+}
+function requireAnnotationDispatchSource(value) {
+  if (value === "annotate_item" || value === "annotate_all" || value === "popup_item" || value === "popup_all" || value === "canvas_item" || value === "canvas_all") {
+    return value;
+  }
+  throw new Error("Invalid source");
+}
+function requireAnnotationPayload(value) {
+  const payload = requireRecord(value, "payload");
+  if (typeof payload.url !== "string" || typeof payload.timestamp !== "string" || !Array.isArray(payload.annotations)) {
+    throw new Error("Invalid payload");
+  }
+  if (typeof payload.title !== "undefined" && typeof payload.title !== "string" || typeof payload.context !== "undefined" && typeof payload.context !== "string") {
+    throw new Error("Invalid payload");
+  }
+  if (typeof payload.screenshotMode !== "undefined" && payload.screenshotMode !== "visible" && payload.screenshotMode !== "full" && payload.screenshotMode !== "none") {
+    throw new Error("Invalid payload");
+  }
+  return payload;
+}
+function requireState(value) {
+  if (value === "visible" || value === "hidden") return value;
+  return "attached";
+}
+var MIN_WAIT_TIMEOUT_MS = 3e3;
+var WAIT_MIN_DELAY_MS = 250;
+var WAIT_MAX_DELAY_MS = 2e3;
+var RELAY_STATUS_TIMEOUT_MS = 1500;
+function clampWaitTimeout(timeoutMs) {
+  if (!Number.isFinite(timeoutMs)) {
+    return MIN_WAIT_TIMEOUT_MS;
+  }
+  return Math.max(timeoutMs, MIN_WAIT_TIMEOUT_MS);
+}
+async function waitForRelayHandshake(relay, observedPort, timeoutMs) {
+  const start = Date.now();
+  let delay = WAIT_MIN_DELAY_MS;
+  while (Date.now() - start < timeoutMs) {
+    const relayStatus = relay.status();
+    if (relayStatus.extensionHandshakeComplete) {
+      return true;
+    }
+    const observedStatus = getMatchingObservedRelayStatus(
+      relayStatus,
+      await fetchRelayObservedStatus(observedPort)
+    );
+    if (observedStatus?.extensionHandshakeComplete) {
+      return true;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, delay));
+    delay = Math.min(delay * 2, WAIT_MAX_DELAY_MS);
+  }
+  return false;
+}
+function resolveObservedPort(relayStatus, configPort) {
+  if (isValidPort(relayStatus.port)) return relayStatus.port;
+  if (isValidPort(configPort)) return configPort;
+  return null;
+}
+function isValidPort(port) {
+  return typeof port === "number" && Number.isInteger(port) && port > 0 && port <= 65535;
+}
+async function fetchRelayObservedStatus(port) {
+  if (!isValidPort(port)) {
+    return null;
+  }
+  try {
+    const response = await fetchWithTimeout(
+      `http://127.0.0.1:${port}/status`,
+      void 0,
+      RELAY_STATUS_TIMEOUT_MS
+    );
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    if (!data || typeof data !== "object") {
+      return null;
+    }
+    const record = data;
+    if (typeof record.instanceId !== "string") {
+      return null;
+    }
+    return {
+      instanceId: record.instanceId,
+      running: Boolean(record.running),
+      port: typeof record.port === "number" ? record.port : void 0,
+      extensionConnected: Boolean(record.extensionConnected),
+      extensionHandshakeComplete: Boolean(record.extensionHandshakeComplete),
+      cdpConnected: Boolean(record.cdpConnected),
+      opsConnected: Boolean(record.opsConnected),
+      pairingRequired: Boolean(record.pairingRequired)
+    };
+  } catch {
+    return null;
+  }
+}
+function getMatchingObservedRelayStatus(relayStatus, observedStatus) {
+  if (!observedStatus) {
+    return null;
+  }
+  return observedStatus.instanceId === relayStatus.instanceId ? observedStatus : null;
+}
+async function loadMacroRuntime() {
+  try {
+    const module = await import("./macros-ND2M7LWU.js");
+    return module;
+  } catch {
+    return null;
+  }
+}
+function parseFallbackMacro(expression, defaultProvider) {
+  const raw = expression.trim();
+  if (!raw.startsWith("@")) {
+    throw new Error("Macro expressions must start with '@'");
+  }
+  const body = raw.slice(1).trim();
+  if (!body) {
+    throw new Error("Macro name is required");
+  }
+  const openParen = body.indexOf("(");
+  const closeParen = body.endsWith(")") ? body.length - 1 : -1;
+  const macroName = openParen >= 0 ? body.slice(0, openParen).trim() : body;
+  const argsBody = openParen >= 0 && closeParen > openParen ? body.slice(openParen + 1, closeParen).trim() : "";
+  const positional = argsBody ? argsBody.split(",").map((part) => part.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean) : [];
+  const query = positional[0] ?? macroName;
+  const provider = defaultProvider ?? "web/default";
+  return {
+    action: {
+      source: "web",
+      operation: "search",
+      input: {
+        query,
+        limit: 10,
+        providerId: provider
+      }
+    },
+    provenance: {
+      macro: macroName,
+      provider,
+      resolvedQuery: query,
+      pack: "fallback",
+      args: {
+        positional,
+        named: {}
+      }
+    }
+  };
+}
+async function resolveMacroExpression(options, config, manager, browserFallbackPort, existingRuntime) {
+  const runtime = await loadMacroRuntime();
+  const registry = runtime?.createDefaultMacroRegistry?.();
+  let resolvedRuntime = "fallback";
+  let resolution;
+  let catalog;
+  if (registry) {
+    resolvedRuntime = "macros";
+    resolution = await registry.resolve(options.expression, {
+      defaultProvider: options.defaultProvider
+    });
+    catalog = options.includeCatalog ? registry.list().map((entry) => ({
+      name: entry.name,
+      pack: entry.pack,
+      description: entry.description
+    })) : void 0;
+  } else {
+    resolution = parseFallbackMacro(options.expression, options.defaultProvider);
+  }
+  if (!options.execute) {
+    const handoff2 = buildMacroResolveSuccessHandoff({
+      expression: options.expression,
+      defaultProvider: options.defaultProvider,
+      execute: false,
+      blocked: false
+    });
+    return {
+      runtime: resolvedRuntime,
+      resolution,
+      ...catalog ? { catalog } : {},
+      ...handoff2
+    };
+  }
+  const execution = await executeMacroWithRuntime({
+    resolution,
+    existingRuntime,
+    config,
+    manager,
+    browserFallbackPort,
+    timeoutMs: options.timeoutMs,
+    browserMode: options.browserMode,
+    useCookies: options.useCookies,
+    challengeAutomationMode: options.challengeAutomationMode,
+    cookiePolicyOverride: options.cookiePolicyOverride
+  });
+  const handoff = buildMacroResolveSuccessHandoff({
+    expression: options.expression,
+    defaultProvider: options.defaultProvider,
+    execute: true,
+    blocked: Boolean(execution.meta.blocker)
+  });
+  return {
+    runtime: resolvedRuntime,
+    resolution,
+    ...catalog ? { catalog } : {},
+    execution,
+    ...handoff
+  };
+}
+
+// src/cli/daemon.ts
+var DEFAULT_DAEMON_PORT = 8788;
+var DAEMON_STOP_DEBUG_ENV = "OPDEVBROWSER_DEBUG_DAEMON_STOP";
+var DAEMON_FINGERPRINT_FILE = "daemon-fingerprint.json";
+var DAEMON_STOP_REASON_HEADER = "x-opendevbrowser-stop-reason";
+var DAEMON_STOP_CLIENT_PID_HEADER = "x-opendevbrowser-stop-client-pid";
+var DAEMON_STOP_FINGERPRINT_HEADER = "x-opendevbrowser-stop-fingerprint";
+var RECOVERABLE_PLAYWRIGHT_TRANSPORT_ERRORS = [
+  "Cannot find context with specified id",
+  "Detached while handling command.",
+  "No frame with given id found"
+];
+var DAEMON_FINGERPRINT_VERSION = "v1";
+function getCacheRoot() {
+  const base = process.env.OPENCODE_CACHE_DIR ?? process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+  return join(base, "opendevbrowser");
+}
+function getDaemonMetadataPath() {
+  return join(getCacheRoot(), "daemon.json");
+}
+function readDaemonMetadata() {
+  const metadataPath = getDaemonMetadataPath();
+  if (!existsSync(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(metadataPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeDaemonMetadata(state) {
+  const metadataPath = getDaemonMetadataPath();
+  mkdirSync(join(getCacheRoot()), { recursive: true });
+  writeFileSync(metadataPath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function clearDaemonMetadata() {
+  const metadataPath = getDaemonMetadataPath();
+  try {
+    unlinkSync(metadataPath);
+  } catch {
+  }
+}
+function resolveCurrentDaemonEntrypointPath(options = {}) {
+  const rawEntry = options.argv1 ?? process.argv[1];
+  if (typeof rawEntry === "string" && rawEntry.trim().length > 0) {
+    return resolve(rawEntry);
+  }
+  const moduleUrl = options.moduleUrl ?? import.meta.url;
+  const cliEntrypoint = resolve(fileURLToPath(new URL("./index.js", moduleUrl)));
+  const entryExists = options.entryExists ?? existsSync;
+  if (entryExists(cliEntrypoint)) {
+    return cliEntrypoint;
+  }
+  return resolve(fileURLToPath(moduleUrl));
+}
+function hashFileContents(entryPath) {
+  try {
+    return createHash("sha256").update(readFileSync(entryPath)).digest("hex");
+  } catch {
+    return "missing";
+  }
+}
+function resolveDaemonFingerprintDistRoot(modulePath) {
+  let currentDir = dirname(modulePath);
+  while (true) {
+    if (basename(currentDir) === "dist") {
+      return currentDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+function readDaemonFingerprintArtifact(modulePath) {
+  const distRoot = resolveDaemonFingerprintDistRoot(modulePath);
+  if (distRoot === null) {
+    return null;
+  }
+  try {
+    const content = readFileSync(join(distRoot, DAEMON_FINGERPRINT_FILE), "utf-8");
+    const payload = JSON.parse(content);
+    if (typeof payload.fingerprint === "string" && payload.fingerprint.trim().length > 0) {
+      return payload.fingerprint.trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function getCurrentDaemonFingerprint(options = {}) {
+  const modulePath = resolve(fileURLToPath(options.moduleUrl ?? import.meta.url));
+  const sharedFingerprint = readDaemonFingerprintArtifact(modulePath);
+  const fingerprintParts = [
+    DAEMON_FINGERPRINT_VERSION,
+    sharedFingerprint ?? hashFileContents(modulePath)
+  ];
+  return createHash("sha256").update(fingerprintParts.join("\n")).digest("hex");
+}
+function isCurrentDaemonFingerprint(fingerprint) {
+  return typeof fingerprint === "string" && fingerprint === getCurrentDaemonFingerprint();
+}
+function createDaemonStopHeaders(token, reason) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    [DAEMON_STOP_FINGERPRINT_HEADER]: getCurrentDaemonFingerprint(),
+    [DAEMON_STOP_REASON_HEADER]: reason
+  };
+  if (process.env[DAEMON_STOP_DEBUG_ENV] === "1") {
+    headers[DAEMON_STOP_CLIENT_PID_HEADER] = String(process.pid);
+  }
+  return headers;
+}
+function resolveDaemonFingerprint(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+  return "missing";
+}
+function isRecoverablePlaywrightTransportError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return RECOVERABLE_PLAYWRIGHT_TRANSPORT_ERRORS.some((pattern) => message.includes(pattern));
+}
+function isRecoverablePlaywrightTransportAssertion(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  const isKnownTransportAssertion = message.includes("Assertion error") || message.includes("No tab attached");
+  if (!isKnownTransportAssertion) {
+    return false;
+  }
+  const stack = error instanceof Error && typeof error.stack === "string" ? error.stack : "";
+  return stack.includes("playwright-core/lib/server/chromium/crConnection.js") || stack.includes("playwright-core/lib/server/transport.js");
+}
+function isAuthorized(request, token) {
+  const header = request.headers.authorization ?? "";
+  if (!header.startsWith("Bearer ")) {
+    return false;
+  }
+  const received = header.slice("Bearer ".length).trim();
+  const expectedBuf = Buffer.from(token, "utf-8");
+  const receivedBuf = Buffer.from(received, "utf-8");
+  if (expectedBuf.length !== receivedBuf.length) {
+    timingSafeEqual(expectedBuf, expectedBuf);
+    return false;
+  }
+  return timingSafeEqual(expectedBuf, receivedBuf);
+}
+function sendJson(response, status, payload) {
+  response.writeHead(status, {
+    "Content-Type": "application/json",
+    "Cache-Control": "no-store"
+  });
+  response.end(JSON.stringify(payload));
+}
+function logDaemonStopDebug(message, details) {
+  if (process.env[DAEMON_STOP_DEBUG_ENV] !== "1") {
+    return;
+  }
+  const suffix = details ? ` ${JSON.stringify(details)}` : "";
+  console.error(`[daemon-stop-debug] ${message}${suffix}`);
+}
+function readSingleHeader(request, name) {
+  const value = request.headers[name];
+  if (typeof value === "string") {
+    return value;
+  }
+  return null;
+}
+var isDaemonCommandRequest = (value) => {
+  if (typeof value.name !== "string") {
+    return false;
+  }
+  if (typeof value.params === "undefined") {
+    return true;
+  }
+  return typeof value.params === "object" && value.params !== null && !Array.isArray(value.params);
+};
+async function startDaemon(options = {}) {
+  const config = typeof options.config === "undefined" ? loadGlobalConfig() : resolveConfig(options.config);
+  const port = options.port ?? config.daemonPort ?? DEFAULT_DAEMON_PORT;
+  const token = options.token ?? config.daemonToken ?? generateSecureToken();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const fingerprint = getCurrentDaemonFingerprint();
+  const core = createOpenDevBrowserCore({
+    directory: options.directory ?? process.cwd(),
+    worktree: options.worktree ?? null,
+    config
+  });
+  await core.ensureRelay(config.relayPort);
+  const server = createServer(async (request, response) => {
+    if (!isAuthorized(request, token)) {
+      sendJson(response, 401, { error: "Unauthorized" });
+      return;
+    }
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    if (request.method === "GET" && url.pathname === "/status") {
+      const relayStatus = core.relay.status();
+      writeDaemonMetadata({
+        port,
+        token,
+        pid: process.pid,
+        relayPort: relayStatus.port ?? config.relayPort,
+        startedAt,
+        fingerprint,
+        hubInstanceId: getHubInstanceId(),
+        relayInstanceId: relayStatus.instanceId,
+        relayEpoch: relayStatus.epoch
+      });
+      sendJson(response, 200, {
+        ok: true,
+        pid: process.pid,
+        fingerprint,
+        hub: { instanceId: getHubInstanceId() },
+        relay: relayStatus,
+        binding: getBindingDiagnostics()
+      });
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/stop") {
+      const stopFingerprint = readSingleHeader(request, DAEMON_STOP_FINGERPRINT_HEADER);
+      logDaemonStopDebug("http.stop", {
+        remoteAddress: request.socket.remoteAddress ?? null,
+        remotePort: request.socket.remotePort ?? null,
+        reason: readSingleHeader(request, DAEMON_STOP_REASON_HEADER),
+        clientPid: readSingleHeader(request, DAEMON_STOP_CLIENT_PID_HEADER),
+        fingerprintMatches: stopFingerprint === fingerprint
+      });
+      if (stopFingerprint !== fingerprint) {
+        sendJson(response, 409, { ok: false, error: "Stale daemon stop request." });
+        return;
+      }
+      sendJson(response, 200, { ok: true });
+      await stop("http.stop");
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/command") {
+      try {
+        const body = await readJson(request);
+        if (!isDaemonCommandRequest(body)) {
+          throw new Error("Invalid daemon command request");
+        }
+        const data = await handleDaemonCommand(core, body);
+        sendJson(response, 200, { ok: true, data });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        sendJson(response, 400, { ok: false, error: message });
+      }
+      return;
+    }
+    sendJson(response, 404, { error: "Not found" });
+  });
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve2());
+  });
+  const state = {
+    port,
+    token,
+    pid: process.pid,
+    relayPort: config.relayPort,
+    startedAt,
+    fingerprint,
+    hubInstanceId: getHubInstanceId(),
+    relayInstanceId: core.relay.status().instanceId,
+    relayEpoch: core.relay.status().epoch
+  };
+  writeDaemonMetadata(state);
+  let stopping = false;
+  const handleRecoverableDaemonError = (channel, error) => {
+    if (!isRecoverablePlaywrightTransportError(error)) {
+      if (isRecoverablePlaywrightTransportAssertion(error)) {
+        const message2 = error instanceof Error ? error.message : String(error ?? "unknown");
+        console.warn(`[daemon] ignored recoverable Playwright transport follow-on (${channel}): ${message2}`);
+        return true;
+      }
+      return false;
+    }
+    const message = error instanceof Error ? error.message : String(error ?? "unknown");
+    console.warn(`[daemon] ignored recoverable Playwright transport error (${channel}): ${message}`);
+    return true;
+  };
+  const uncaughtExceptionHandler = (error) => {
+    if (handleRecoverableDaemonError("uncaughtException", error)) {
+      return;
+    }
+    console.error(error);
+    void stop("uncaughtException").finally(() => {
+      process.exitCode = 1;
+    });
+  };
+  const unhandledRejectionHandler = (reason) => {
+    if (handleRecoverableDaemonError("unhandledRejection", reason)) {
+      return;
+    }
+    console.error(reason);
+    void stop("unhandledRejection").finally(() => {
+      process.exitCode = 1;
+    });
+  };
+  const stop = async (reason = "unknown") => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    logDaemonStopDebug("stop.begin", { reason });
+    clearDaemonMetadata();
+    clearBinding();
+    process.off("SIGINT", sigintHandler);
+    process.off("SIGTERM", sigtermHandler);
+    process.off("uncaughtException", uncaughtExceptionHandler);
+    process.off("unhandledRejection", unhandledRejectionHandler);
+    core.cleanup();
+    await new Promise((resolve2) => {
+      server.close(() => resolve2());
+    });
+    logDaemonStopDebug("stop.complete", { reason });
+  };
+  const sigintHandler = () => {
+    void stop("SIGINT").catch(() => {
+    });
+  };
+  const sigtermHandler = () => {
+    void stop("SIGTERM").catch(() => {
+    });
+  };
+  process.on("SIGINT", sigintHandler);
+  process.on("SIGTERM", sigtermHandler);
+  process.on("uncaughtException", uncaughtExceptionHandler);
+  process.on("unhandledRejection", unhandledRejectionHandler);
+  return { state, stop };
+}
+function readJson(request) {
+  return new Promise((resolve2, reject) => {
+    let data = "";
+    request.setEncoding("utf8");
+    request.on("data", (chunk) => {
+      data += chunk;
+    });
+    request.on("end", () => {
+      try {
+        const parsed = JSON.parse(data || "{}");
+        if (!parsed || typeof parsed !== "object") {
+          reject(new Error("Invalid JSON body"));
+          return;
+        }
+        resolve2(parsed);
+      } catch (error) {
+        reject(error);
+      }
+    });
+    request.on("error", reject);
+  });
+}
+
+// src/cli/daemon-status-policy.ts
+var DEFAULT_DAEMON_STATUS_FETCH_OPTIONS = {
+  timeoutMs: 5e3,
+  retryAttempts: 5,
+  retryDelayMs: 250
+};
+
+// src/cli/daemon-status.ts
+var DEFAULT_DAEMON_STATUS_TIMEOUT_MS = DEFAULT_DAEMON_STATUS_FETCH_OPTIONS.timeoutMs;
+var sleep = async (delayMs) => {
+  if (!(Number.isFinite(delayMs) && delayMs > 0)) {
+    return;
+  }
+  await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+};
+var resolveRetryAttempts = (retryAttempts) => {
+  return typeof retryAttempts === "number" && Number.isFinite(retryAttempts) && retryAttempts > 1 ? Math.floor(retryAttempts) : 1;
+};
+var resolveRetryDelayMs = (retryDelayMs) => {
+  return typeof retryDelayMs === "number" && Number.isFinite(retryDelayMs) && retryDelayMs > 0 ? retryDelayMs : 0;
+};
+var resolveStatusTimeoutMs = (timeoutMs) => {
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_DAEMON_STATUS_TIMEOUT_MS;
+};
+var withFingerprintCurrent = (status) => ({
+  ...status,
+  fingerprintCurrent: isCurrentDaemonFingerprint(status.fingerprint)
+});
+var readRemainingBudgetMs = (deadlineMs) => {
+  return Math.max(0, deadlineMs - Date.now());
+};
+var readSeedTimeoutMs = (remainingBudgetMs, remainingSeedCount) => {
+  if (remainingSeedCount <= 1) {
+    return remainingBudgetMs;
+  }
+  return Math.max(1, Math.floor(remainingBudgetMs / remainingSeedCount));
+};
+var resolveDaemonStatusSeeds = (metadata, config) => {
+  const seeds = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addSeed = (seed) => {
+    if (!seed) {
+      return;
+    }
+    const key = `${seed.port}:${seed.token}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    seeds.push(seed);
+  };
+  addSeed(
+    config.daemonPort > 0 && config.daemonToken ? {
+      port: config.daemonPort,
+      token: config.daemonToken,
+      relayPort: config.relayPort
+    } : null
+  );
+  addSeed(metadata);
+  return seeds;
+};
+async function fetchDaemonStatus(port, token, options = {}) {
+  const attempts = resolveRetryAttempts(options.retryAttempts);
+  const retryDelayMs = resolveRetryDelayMs(options.retryDelayMs);
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      const timedResponse = await fetchWithTimeoutContext(`http://127.0.0.1:${port}/status`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${token}` }
+      }, options.timeoutMs);
+      try {
+        if (timedResponse.response.ok) {
+          const status = await readResponseJsonWithTimeout(
+            timedResponse.response,
+            timedResponse.signal,
+            timedResponse.timeoutMs
+          );
+          return withFingerprintCurrent(status);
+        }
+      } finally {
+        timedResponse.dispose();
+      }
+    } catch {
+    }
+    if (attempt < attempts) {
+      await sleep(retryDelayMs);
+    }
+  }
+  return null;
+}
+async function fetchDaemonStatusFromMetadata(config, options = {}) {
+  const resolvedConfig = config ?? loadGlobalConfig();
+  const attempts = resolveRetryAttempts(options.retryAttempts);
+  const retryDelayMs = resolveRetryDelayMs(options.retryDelayMs);
+  const deadlineMs = Date.now() + resolveStatusTimeoutMs(options.timeoutMs);
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const metadata = readDaemonMetadata();
+    const seeds = resolveDaemonStatusSeeds(metadata, resolvedConfig);
+    for (let seedIndex = 0; seedIndex < seeds.length; seedIndex += 1) {
+      const seed = seeds[seedIndex];
+      if (!seed) {
+        continue;
+      }
+      const remainingBudgetMs = readRemainingBudgetMs(deadlineMs);
+      if (remainingBudgetMs <= 0) {
+        return null;
+      }
+      const timeoutMs = readSeedTimeoutMs(remainingBudgetMs, seeds.length - seedIndex);
+      const status = await fetchDaemonStatus(seed.port, seed.token, {
+        timeoutMs
+      });
+      if (status?.ok) {
+        persistDaemonStatusMetadata(seed, status, resolvedConfig);
+        return status;
+      }
+    }
+    if (attempt < attempts) {
+      const remainingBudgetMs = readRemainingBudgetMs(deadlineMs);
+      if (remainingBudgetMs <= 0) {
+        break;
+      }
+      await sleep(Math.min(retryDelayMs, remainingBudgetMs));
+    }
+  }
+  return null;
+}
+function persistDaemonStatusMetadata(base, status, config) {
+  const resolvedConfig = config ?? loadGlobalConfig();
+  writeDaemonMetadata({
+    port: base.port,
+    token: base.token,
+    pid: status.pid,
+    relayPort: status.relay.port ?? resolvedConfig.relayPort,
+    startedAt: base.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    fingerprint: resolveDaemonFingerprint(status.fingerprint, base.fingerprint),
+    hubInstanceId: status.hub.instanceId,
+    relayInstanceId: status.relay.instanceId,
+    relayEpoch: status.relay.epoch
+  });
+}
+
+export {
+  inspectSession,
+  buildCorrelatedAuditBundle,
+  captureInspiredesignReferenceFromManager,
+  executeMacroWithRuntime,
+  fetchWithTimeout,
+  fetchWithTimeoutContext,
+  readResponseTextWithTimeout,
+  readResponseJsonWithTimeout,
+  DAEMON_STOP_DEBUG_ENV,
+  getCacheRoot,
+  readDaemonMetadata,
+  resolveCurrentDaemonEntrypointPath,
+  isCurrentDaemonFingerprint,
+  createDaemonStopHeaders,
+  startDaemon,
+  DEFAULT_DAEMON_STATUS_FETCH_OPTIONS,
+  fetchDaemonStatus,
+  fetchDaemonStatusFromMetadata,
+  persistDaemonStatusMetadata
+};
+//# sourceMappingURL=chunk-LBPELU7L.js.map