pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/packaged/lib/runtime.js

@@ -0,0 +1,3027 @@
+// dist/extensions/agent-browser/lib/command-capabilities.js
+var ADDITIONAL_COMMAND_TOKENS = [
+  "a11y",
+  "auth",
+  "chat",
+  "clipboard",
+  "confirm",
+  "connect",
+  "dashboard",
+  "deny",
+  "device",
+  "dialog",
+  "diff",
+  "doctor",
+  "errors",
+  "eval",
+  "find",
+  "frame",
+  "get",
+  "highlight",
+  "inspect",
+  "install",
+  "is",
+  "mcp",
+  "plugin",
+  "plugins",
+  "profiles",
+  "profiler",
+  "react",
+  "record",
+  "removeinitscript",
+  "session",
+  "set",
+  "skills",
+  "snapshot",
+  "state",
+  "stream",
+  "trace",
+  "upgrade",
+  "vitals",
+  "wait",
+  "web-vitals",
+  "webmcp",
+  "window"
+];
+var COMMAND_CAPABILITIES = [
+  {
+    command: "back",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "batch",
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "check",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "click",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    aliases: ["quit", "exit"],
+    closesSession: true,
+    command: "close",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "console",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "cookies",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "dblclick",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "dialog",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "diff",
+    guardsPageRefs: true
+  },
+  {
+    command: "download",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true
+  },
+  {
+    command: "drag",
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true
+  },
+  {
+    command: "errors",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "eval",
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "fill",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "find",
+    eligibleForElectronHealthProbe: true
+  },
+  {
+    command: "frame",
+    guardsPageRefs: true
+  },
+  {
+    command: "focus",
+    guardsPageRefs: true
+  },
+  {
+    command: "forward",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "get",
+    guardsPageRefs: true
+  },
+  {
+    command: "highlight",
+    guardsPageRefs: true
+  },
+  {
+    command: "hover",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "is",
+    guardsPageRefs: true
+  },
+  {
+    command: "keydown",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "keyboard",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "keyup",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "mouse",
+    eligibleForElectronHealthProbe: true,
+    invalidatesBatchRefs: true
+  },
+  {
+    command: "network",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    aliases: ["goto", "navigate"],
+    command: "open",
+    eligibleForPageChangeSummary: true,
+    excludedFromPinning: true,
+    invalidatesBatchRefs: true,
+    openNavigation: true
+  },
+  {
+    command: "pdf",
+    eligibleForPageChangeSummary: true
+  },
+  {
+    aliases: ["key"],
+    command: "press",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "pushstate",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "reload",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    navigationObservable: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "read",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "screenshot",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true
+  },
+  {
+    command: "scroll",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    aliases: ["scrollinto"],
+    command: "scrollintoview",
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "select",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "session",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "storage",
+    readOnlyDiagnosticSessionTarget: true
+  },
+  {
+    command: "swipe",
+    eligibleForPageChangeSummary: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "tab",
+    excludedFromPinning: true,
+    excludedFromPostCommandCorrection: true
+  },
+  {
+    command: "tap",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "type",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "uncheck",
+    eligibleForElectronHealthProbe: true,
+    eligibleForPageChangeSummary: true,
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true,
+    triggersPostMutationSnapshot: true
+  },
+  {
+    command: "upload",
+    guardsPageRefs: true,
+    invalidatesBatchRefs: true
+  }
+];
+var COMMAND_CAPABILITY_BY_NAME = /* @__PURE__ */ new Map();
+for (const entry of COMMAND_CAPABILITIES) {
+  COMMAND_CAPABILITY_BY_NAME.set(entry.command, entry);
+  for (const alias of entry.aliases ?? []) {
+    COMMAND_CAPABILITY_BY_NAME.set(alias, entry);
+  }
+}
+var KNOWN_COMMAND_TOKENS = /* @__PURE__ */ new Set([
+  ...COMMAND_CAPABILITY_BY_NAME.keys(),
+  ...ADDITIONAL_COMMAND_TOKENS
+]);
+function isKnownCommandToken(token) {
+  return KNOWN_COMMAND_TOKENS.has(token);
+}
+function getCommandCapability(command) {
+  return command === void 0 ? void 0 : COMMAND_CAPABILITY_BY_NAME.get(command);
+}
+function hasCommandCapability(command, capability) {
+  return getCommandCapability(command)?.[capability] === true;
+}
+
+// dist/extensions/agent-browser/lib/command-taxonomy.js
+function isCloseCommand(command) {
+  return hasCommandCapability(command, "closesSession");
+}
+function isCloseAllCommand(commandTokens) {
+  return isCloseCommand(commandTokens[0]) && commandTokens.slice(1).includes("--all");
+}
+function isOpenNavigationCommand(command) {
+  return hasCommandCapability(command, "openNavigation");
+}
+
+// dist/extensions/agent-browser/lib/session-identity.js
+var SESSION_COMPONENT_ALPHANUMERIC = /^[\p{Alphabetic}\p{Number}]$/u;
+function canonicalizeAgentBrowserNamespace(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  let normalized = "";
+  let lastWasSeparator = false;
+  for (const character of value) {
+    if (SESSION_COMPONENT_ALPHANUMERIC.test(character)) {
+      normalized += character.toLowerCase();
+      lastWasSeparator = false;
+      continue;
+    }
+    if (normalized.length > 0 && !lastWasSeparator) {
+      normalized += character === "_" ? "_" : "-";
+      lastWasSeparator = true;
+    }
+  }
+  const result = normalized.replace(/[-_]+$/u, "");
+  return result.length > 0 ? result : void 0;
+}
+function foldAgentBrowserFilesystemIdentity(value, platform) {
+  if (platform !== "darwin" && platform !== "win32") {
+    return value;
+  }
+  return value.normalize("NFC").toLowerCase().toUpperCase().toLowerCase().normalize("NFC");
+}
+function getAgentBrowserSessionIdentityKey(sessionName, namespace, platform = process.platform) {
+  const canonicalNamespace = canonicalizeAgentBrowserNamespace(namespace);
+  const canonicalSessionName = foldAgentBrowserFilesystemIdentity(sessionName, platform);
+  return canonicalNamespace !== void 0 ? `${foldAgentBrowserFilesystemIdentity(canonicalNamespace, platform)}\0${canonicalSessionName}` : canonicalSessionName;
+}
+function isAgentBrowserSessionIdentityKeyInNamespace(identityKey, namespace) {
+  const prefix = getAgentBrowserSessionIdentityKey("", namespace);
+  return prefix.length > 0 ? identityKey.startsWith(prefix) : !identityKey.includes("\0");
+}
+
+// dist/extensions/agent-browser/lib/argv-grammar.js
+var GLOBAL_VALUE_FLAGS = [
+  "--session",
+  "--namespace",
+  "--cdp",
+  "--config",
+  "--profile",
+  "--session-name",
+  "--restore-save",
+  "--restore-check-url",
+  "--restore-check-text",
+  "--restore-check-fn",
+  "--proxy",
+  "--proxy-bypass",
+  "--ca-cert",
+  "--headers",
+  "--executable-path",
+  "--extension",
+  "--init-script",
+  "--enable",
+  "--provider",
+  "-p",
+  "--engine",
+  "--state",
+  "--download-path",
+  "--screenshot-dir",
+  "--screenshot-format",
+  "--screenshot-quality",
+  "--color-scheme",
+  "--device",
+  "--args",
+  "--user-agent",
+  "--allowed-domains",
+  "--action-policy",
+  "--confirm-actions",
+  "--max-output",
+  "--model",
+  "--idle-timeout",
+  "--input-mode"
+];
+var COMMAND_VALUE_FLAGS = [
+  "--allowed-origins",
+  "--baseline",
+  "--body",
+  "--categories",
+  "--content",
+  "--curl",
+  "--depth",
+  "-d",
+  "--domain",
+  "--expires",
+  "--filter",
+  "--frame",
+  "--fn",
+  "--label",
+  "--load",
+  "--method",
+  "--name",
+  "--older-than",
+  "--output",
+  "--prefix",
+  "--path",
+  "--port",
+  "--params",
+  "--resource-type",
+  "--resource-types",
+  "--sameSite",
+  "--scope",
+  "--selector",
+  "-s",
+  "--status",
+  "--tags",
+  "--text",
+  "--threshold",
+  "--timeout",
+  "--type",
+  "--url",
+  "--username",
+  "--password",
+  "--wait-until"
+];
+var OPTIONAL_GLOBAL_VALUE_FLAGS = /* @__PURE__ */ new Set(["--restore"]);
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  ...GLOBAL_VALUE_FLAGS,
+  ...COMMAND_VALUE_FLAGS
+]);
+var PREVALIDATED_VALUE_FLAGS = new Set(GLOBAL_VALUE_FLAGS);
+var GLOBAL_VALUE_FLAGS_ALLOWING_DASH_VALUE = /* @__PURE__ */ new Set([
+  "--args",
+  "--session"
+]);
+var GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES = /* @__PURE__ */ new Set([
+  "--allow-file-access",
+  "--annotate",
+  "--auto-connect",
+  "--confirm-interactive",
+  "--content-boundaries",
+  "--debug",
+  "--headed",
+  "--hide-scrollbars",
+  "--ignore-https-errors",
+  "--json",
+  "--no-auto-dialog",
+  "--no-ca-cert",
+  "--no-pin-tab",
+  "--no-webmcp",
+  "--offline",
+  "--pin-tab",
+  "--quick",
+  "--fix",
+  "--quiet",
+  "-q",
+  "--verbose",
+  "-v",
+  "--webgpu"
+]);
+function getBooleanFlagValue(args, flag) {
+  let enabled;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === flag) {
+      enabled = args[index + 1] !== "false";
+      if (["true", "false"].includes(args[index + 1] ?? "")) {
+        index += 1;
+      }
+      continue;
+    }
+    if (PREVALIDATED_VALUE_FLAGS.has(token)) {
+      index += 1;
+      continue;
+    }
+    if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(token) && ["true", "false"].includes(args[index + 1] ?? "")) {
+      index += 1;
+    }
+  }
+  return enabled;
+}
+function isBooleanFlagEnabled(args, flag) {
+  return getBooleanFlagValue(args, flag) ?? false;
+}
+function isUpstreamEnvFlagEnabled(value) {
+  return value !== void 0 && !["", "0", "false", "no"].includes(value.toLowerCase());
+}
+function scanUpstreamGlobalFlagOccurrences(args, targetFlag) {
+  const occurrences = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === targetFlag) {
+      occurrences.push({ index, value: args[index + 1] });
+      index += 1;
+      continue;
+    }
+    if (PREVALIDATED_VALUE_FLAGS.has(token)) {
+      index += 1;
+      continue;
+    }
+    if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(token) && ["true", "false"].includes(args[index + 1] ?? "")) {
+      index += 1;
+    }
+  }
+  return occurrences;
+}
+function extractExplicitSessionName(args) {
+  return scanUpstreamGlobalFlagOccurrences(args, "--session").at(-1)?.value;
+}
+function extractExplicitNamespace(args) {
+  return canonicalizeAgentBrowserNamespace(scanUpstreamGlobalFlagOccurrences(args, "--namespace").at(-1)?.value);
+}
+function resolveAgentBrowserNamespace(args, envValue) {
+  const occurrences = scanUpstreamGlobalFlagOccurrences(args, "--namespace");
+  if (occurrences.length > 0) {
+    return canonicalizeAgentBrowserNamespace(occurrences.at(-1)?.value) ?? "";
+  }
+  return canonicalizeAgentBrowserNamespace(envValue);
+}
+function getFlagName(token) {
+  return token.split("=", 1).at(0) ?? token;
+}
+function isNonFlagToken(token) {
+  return typeof token === "string" && !token.startsWith("-");
+}
+function hasOnlyBooleanFlags(tokens, allowedFlags) {
+  return tokens.every((token) => token.startsWith("-") && allowedFlags.has(getFlagName(token)));
+}
+function hasOnlyOptionFlags(tokens, allowedBooleanFlags, allowedValueFlags) {
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token.startsWith("-")) {
+      return false;
+    }
+    const flagName = getFlagName(token);
+    if (allowedBooleanFlags.has(flagName)) {
+      continue;
+    }
+    if (!allowedValueFlags.has(flagName)) {
+      return false;
+    }
+    if (token.includes("=")) {
+      continue;
+    }
+    const value = tokens.at(index + 1);
+    if (!isNonFlagToken(value)) {
+      return false;
+    }
+    index += 1;
+  }
+  return true;
+}
+function optionalGlobalValueFlagConsumesNext(flag, nextToken) {
+  if (!OPTIONAL_GLOBAL_VALUE_FLAGS.has(flag) || nextToken === void 0 || nextToken.startsWith("-")) {
+    return false;
+  }
+  return !isKnownCommandToken(nextToken);
+}
+function globalFlagWidth(token, next, seenCommand) {
+  if (token.startsWith("--restore=")) {
+    return 1;
+  }
+  if (token === "--restore") {
+    return !seenCommand && optionalGlobalValueFlagConsumesNext(token, next) ? 2 : 1;
+  }
+  if (PREVALIDATED_VALUE_FLAGS.has(token)) {
+    return 2;
+  }
+  if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(token)) {
+    return ["true", "false"].includes(next ?? "") ? 2 : 1;
+  }
+  return 0;
+}
+function projectUpstreamGlobalFlags(args) {
+  const indices = [];
+  const tokens = [];
+  let seenCommand = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    const width = globalFlagWidth(token, args[index + 1], seenCommand);
+    if (width > 0) {
+      index += width - 1;
+      continue;
+    }
+    tokens.push(token);
+    indices.push(index);
+    if (isKnownCommandToken(token)) {
+      seenCommand = true;
+    }
+  }
+  return { indices, tokens };
+}
+function stripUpstreamGlobalFlags(args) {
+  return projectUpstreamGlobalFlags(args).tokens;
+}
+function stripSessionlessShapeGlobalFlags(commandTokens) {
+  const stripped = [];
+  for (let index = 0; index < commandTokens.length; index += 1) {
+    const token = commandTokens[index];
+    const flagName = getFlagName(token);
+    if (token === "--json") {
+      continue;
+    }
+    if ((flagName === "--session" || flagName === "--namespace") && !token.includes("=")) {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--session=") || token.startsWith("--namespace=")) {
+      continue;
+    }
+    stripped.push(token);
+  }
+  return stripped;
+}
+
+// dist/extensions/agent-browser/lib/argv-descriptor.js
+function isBooleanLiteral(token) {
+  const normalized = token?.trim().toLowerCase();
+  return normalized === "true" || normalized === "false";
+}
+function flagConsumesFollowingToken(token, nextToken) {
+  const normalizedToken = token.split("=", 1).at(0) ?? token;
+  if (optionalGlobalValueFlagConsumesNext(normalizedToken, nextToken)) {
+    return true;
+  }
+  if (token.includes("=")) {
+    return false;
+  }
+  return VALUE_FLAGS.has(normalizedToken) || GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(normalizedToken) && isBooleanLiteral(nextToken);
+}
+function findCommandStartIndex(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token.startsWith("--session=") || token.startsWith("--namespace=") || token.startsWith("--restore=")) {
+      continue;
+    }
+    if (token.startsWith("-")) {
+      if (flagConsumesFollowingToken(token, args[index + 1])) {
+        index += 1;
+      }
+      continue;
+    }
+    return index;
+  }
+  return void 0;
+}
+function extractCommandTokens(args) {
+  const commandStartIndex = findCommandStartIndex(args);
+  return commandStartIndex === void 0 ? [] : args.slice(commandStartIndex);
+}
+function extractUpstreamCommandTokens(args) {
+  return stripUpstreamGlobalFlags(extractCommandTokens(args));
+}
+function waitDownloadShape(considered, downloadIndex) {
+  const next = considered.at(downloadIndex + 1);
+  const candidate = next?.token.startsWith("--") === false ? next : void 0;
+  return {
+    downloadPath: candidate?.token,
+    downloadPathIndex: candidate?.index,
+    subcommand: considered[downloadIndex].token
+  };
+}
+function parseWaitCommandTokens(commandTokens) {
+  if (commandTokens[0] !== "wait") {
+    return {};
+  }
+  const considered = commandTokens.slice(1).map((token, offset) => ({ index: offset + 1, token }));
+  const timeoutIndex = considered.findIndex((entry) => entry.token === "--timeout");
+  if (timeoutIndex >= 0) {
+    considered.splice(timeoutIndex, Math.min(2, considered.length - timeoutIndex));
+  }
+  for (const flags of [
+    ["--url", "-u"],
+    ["--load", "-l"],
+    ["--fn", "-f"],
+    ["--text", "-t"]
+  ]) {
+    const match = considered.find((entry) => flags.some((flag) => flag === entry.token));
+    if (match) {
+      return { subcommand: match.token };
+    }
+  }
+  const downloadIndex = considered.findIndex((entry) => entry.token === "--download" || entry.token === "-d");
+  if (downloadIndex >= 0) {
+    return waitDownloadShape(considered, downloadIndex);
+  }
+  return { subcommand: considered[0]?.token };
+}
+function getOpenCommandTarget(commandTokens) {
+  for (let index = 1; index < commandTokens.length; index += 1) {
+    const token = commandTokens[index];
+    if (token === "--init-script" || token === "--enable") {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--init-script=") || token.startsWith("--enable=")) {
+      continue;
+    }
+    if (token.startsWith("-")) {
+      continue;
+    }
+    return token;
+  }
+  return void 0;
+}
+function getCommandSubcommand(tokens) {
+  if (isOpenNavigationCommand(tokens.at(0))) {
+    return getOpenCommandTarget(tokens);
+  }
+  if (tokens.at(0) === "wait") {
+    return parseWaitCommandTokens(tokens).subcommand;
+  }
+  return tokens.at(1);
+}
+function parseCommandInfoFromTokens(upstreamCommandTokens) {
+  const command = upstreamCommandTokens[0];
+  return {
+    command,
+    subcommand: getCommandSubcommand(upstreamCommandTokens)
+  };
+}
+function parseCommandInfo(args) {
+  return parseCommandInfoFromTokens(extractUpstreamCommandTokens(args));
+}
+function parseArgvDescriptor(args) {
+  const commandTokens = extractCommandTokens(args);
+  const upstreamCommandTokens = stripUpstreamGlobalFlags(commandTokens);
+  return {
+    commandInfo: parseCommandInfoFromTokens(upstreamCommandTokens),
+    commandTokens,
+    upstreamCommandTokens
+  };
+}
+
+// dist/extensions/agent-browser/lib/read-command.js
+var READ_VALUE_OPTIONS = /* @__PURE__ */ new Set(["--filter", "--llms", "--timeout"]);
+var READ_BOOLEAN_OPTIONS = /* @__PURE__ */ new Set(["--raw", "--require-md", "--outline", "--json"]);
+function validReadOption(flag, value) {
+  if (value === void 0) {
+    return false;
+  }
+  if (flag === "--llms") {
+    return ["index", "full"].includes(value);
+  }
+  if (flag === "--timeout") {
+    return /^\+?\d+$/.test(value) && BigInt(value) > 0n && BigInt(value) <= 18446744073709551615n;
+  }
+  return true;
+}
+function getExplicitReadUrl(commandTokens) {
+  if (commandTokens[0] !== "read") {
+    return void 0;
+  }
+  let url;
+  const options = /* @__PURE__ */ new Set();
+  for (let index = 1; index < commandTokens.length; index += 1) {
+    const token = commandTokens[index];
+    if (READ_VALUE_OPTIONS.has(token)) {
+      if (!validReadOption(token, commandTokens.at(++index))) {
+        return null;
+      }
+      options.add(token);
+    } else if (READ_BOOLEAN_OPTIONS.has(token)) {
+      options.add(token);
+    } else if (token.startsWith("--") || url !== void 0) {
+      return null;
+    } else {
+      url = token;
+    }
+  }
+  return options.has("--llms") && options.has("--outline") ? null : url;
+}
+
+// dist/extensions/agent-browser/lib/parsing.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// dist/extensions/agent-browser/lib/input-modes/shared.js
+function isString(value) {
+  return typeof value === "string";
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every(isString);
+}
+
+// dist/extensions/agent-browser/lib/results/text.js
+function stringifyUnknown(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  try {
+    const serialized = JSON.stringify(value, null, 2);
+    return typeof serialized === "string" ? serialized : "";
+  } catch {
+    return stringifyFallback(value);
+  }
+}
+function stringifyFallback(value) {
+  if (typeof value === "bigint" || typeof value === "symbol" || typeof value === "function") {
+    return String(value);
+  }
+  return Object.prototype.toString.call(value);
+}
+
+// dist/extensions/agent-browser/lib/orchestration/batch-stdin.js
+var BATCH_STDIN_EXAMPLE = ' Example: { "args": ["batch"], "stdin": "[[\\"get\\",\\"title\\"],[\\"get\\",\\"url\\"]]" }';
+var BatchWords = class {
+  token = "";
+  tokens = [];
+  inDoubleQuote = false;
+  inSingleQuote = false;
+  consumeQuote(character) {
+    if (character === '"' && !this.inSingleQuote) {
+      this.inDoubleQuote = !this.inDoubleQuote;
+      return true;
+    }
+    if (character === "'" && !this.inDoubleQuote) {
+      this.inSingleQuote = !this.inSingleQuote;
+      return true;
+    }
+    return false;
+  }
+  finishWord() {
+    if (this.token.length > 0) {
+      this.tokens.push(this.token);
+      this.token = "";
+    }
+  }
+  consume(character, next) {
+    if (character === "\\" && !this.inSingleQuote) {
+      if (next !== void 0) {
+        this.token += next;
+        return true;
+      }
+      return false;
+    }
+    if (this.consumeQuote(character)) {
+      return false;
+    }
+    if (character === " " && !this.inDoubleQuote && !this.inSingleQuote) {
+      this.finishWord();
+    } else {
+      this.token += character;
+    }
+    return false;
+  }
+  finish() {
+    this.finishWord();
+    return this.tokens.length > 0 ? { step: this.tokens } : { error: "batch command is empty" };
+  }
+};
+function parseBatchCommandArgument(command) {
+  const words = new BatchWords();
+  for (let index = 0; index < command.length; index++) {
+    if (words.consume(command[index], command.at(index + 1))) {
+      index++;
+    }
+  }
+  return words.finish();
+}
+function validateUserBatchStep(step, index) {
+  if (!Array.isArray(step)) {
+    return {
+      error: `agent_browser batch stdin step ${index} must be an array of string command tokens.${BATCH_STDIN_EXAMPLE}`,
+      ok: false
+    };
+  }
+  if (!isStringArray(step)) {
+    const invalidTokenIndex = step.findIndex((token) => typeof token !== "string");
+    return {
+      error: `agent_browser batch stdin step ${index} token ${invalidTokenIndex} must be a string.${BATCH_STDIN_EXAMPLE}`,
+      ok: false
+    };
+  }
+  return { ok: true, step };
+}
+function parseBatchStdinJsonArray(stdin) {
+  if (stdin === void 0) {
+    return { steps: [] };
+  }
+  try {
+    const parsed = JSON.parse(stdin);
+    if (!Array.isArray(parsed)) {
+      return {
+        error: `agent_browser batch stdin must be a JSON array of command steps.${BATCH_STDIN_EXAMPLE}`
+      };
+    }
+    return { steps: parsed };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : stringifyUnknown(error);
+    return {
+      error: `agent_browser batch stdin could not be parsed as JSON: ${message}.${BATCH_STDIN_EXAMPLE}`
+    };
+  }
+}
+function parseUserBatchStdin(stdin) {
+  const parsed = parseBatchStdinJsonArray(stdin);
+  if (parsed.error !== void 0 || parsed.steps === void 0) {
+    return parsed.error !== void 0 ? { error: parsed.error } : { steps: [] };
+  }
+  const steps = [];
+  for (const [index, rawStep] of parsed.steps.entries()) {
+    const validated = validateUserBatchStep(rawStep, index);
+    if (!validated.ok) {
+      return { error: validated.error };
+    }
+    steps.push(validated.step);
+  }
+  return { steps };
+}
+function getUpstreamEffectiveBatchSteps(commandTokens, stdin) {
+  if (commandTokens[0] !== "batch") {
+    return [];
+  }
+  const argumentSteps = commandTokens.slice(1).flatMap((command) => {
+    if (command === "--bail") {
+      return [];
+    }
+    const step = parseBatchCommandArgument(command).step;
+    return step ? [step] : [];
+  });
+  if (commandTokens.slice(1).some((token) => token !== "--bail")) {
+    return argumentSteps;
+  }
+  return parseUserBatchStdin(stdin).steps?.filter((step) => step.length > 0) ?? [];
+}
+
+// dist/extensions/agent-browser/lib/command-policy.js
+var SESSIONLESS_AUTH_SUBCOMMANDS = /* @__PURE__ */ new Set(["save", "list", "show", "delete", "remove"]);
+var PLUGIN_SESSIONLESS_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "show", "add", "run"]);
+var EMPTY_BOOLEAN_FLAGS = /* @__PURE__ */ new Set();
+var JSON_BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--json"]);
+var AUTH_SAVE_BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--json", "--password-stdin"]);
+var AUTH_SAVE_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--password",
+  "--password-selector",
+  "--submit-selector",
+  "--url",
+  "--username",
+  "--username-selector"
+]);
+var DASHBOARD_VALUE_FLAGS = /* @__PURE__ */ new Set(["--allowed-origins", "--port"]);
+var DOCTOR_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "--fix",
+  "--headed",
+  "--json",
+  "--offline",
+  "--quick",
+  "--webgpu"
+]);
+var INSTALL_BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--with-deps", "-d"]);
+var STATE_SESSIONLESS_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "show", "clear", "clean", "rename"]);
+var STATE_CLEAN_VALUE_FLAGS = /* @__PURE__ */ new Set(["--older-than"]);
+var SESSION_ID_VALUE_FLAGS = /* @__PURE__ */ new Set(["--scope", "--prefix"]);
+function isSessionlessAuthCommand(commandTokens) {
+  const subcommand = commandTokens.at(1);
+  const target = commandTokens.at(2);
+  const rest = commandTokens.slice(3);
+  if (!SESSIONLESS_AUTH_SUBCOMMANDS.has(subcommand ?? "")) {
+    return false;
+  }
+  if (subcommand === "list") {
+    return target === void 0;
+  }
+  if (!isNonFlagToken(target)) {
+    return false;
+  }
+  if (subcommand === "save") {
+    return hasOnlyOptionFlags(rest, AUTH_SAVE_BOOLEAN_FLAGS, AUTH_SAVE_VALUE_FLAGS);
+  }
+  return rest.length === 0;
+}
+function isSessionlessDashboardCommand(commandTokens) {
+  const [, subcommand, ...rest] = commandTokens;
+  if (subcommand === "stop") {
+    return rest.length === 0;
+  }
+  return hasOnlyOptionFlags(subcommand === "start" ? rest : commandTokens.slice(1), JSON_BOOLEAN_FLAGS, DASHBOARD_VALUE_FLAGS);
+}
+function isSessionlessStateClear(operands) {
+  const firstArg = operands.at(0);
+  const secondArg = operands.at(1);
+  const rest = operands.slice(2);
+  if ((firstArg === "--all" || firstArg === "-a") && secondArg === void 0) {
+    return true;
+  }
+  return isNonFlagToken(firstArg) && (secondArg === void 0 || secondArg === "--all" && rest.length === 0);
+}
+function isSessionlessStateCommand(commandTokens) {
+  const subcommand = commandTokens.at(1);
+  const firstArg = commandTokens.at(2);
+  const secondArg = commandTokens.at(3);
+  const rest = commandTokens.slice(4);
+  if (!STATE_SESSIONLESS_SUBCOMMANDS.has(subcommand ?? "")) {
+    return false;
+  }
+  switch (subcommand) {
+    case void 0:
+      return false;
+    case "list":
+      return firstArg === void 0;
+    case "show":
+      return isNonFlagToken(firstArg) && secondArg === void 0;
+    case "rename":
+      return isNonFlagToken(firstArg) && isNonFlagToken(secondArg) && rest.length === 0;
+    case "clean": {
+      const optionTokens = commandTokens.slice(2);
+      return optionTokens.length > 0 && hasOnlyOptionFlags(optionTokens, EMPTY_BOOLEAN_FLAGS, STATE_CLEAN_VALUE_FLAGS);
+    }
+    case "clear":
+      return isSessionlessStateClear(commandTokens.slice(2));
+    default:
+      return false;
+  }
+}
+function isSessionlessPluginCommand(commandTokens) {
+  const subcommand = commandTokens.at(1);
+  if (subcommand === void 0) {
+    return true;
+  }
+  return PLUGIN_SESSIONLESS_SUBCOMMANDS.has(subcommand);
+}
+function isSessionlessSessionCommand(commandTokens) {
+  const [, subcommand, ...rest] = commandTokens;
+  if (subcommand === "list" || subcommand === "info") {
+    return rest.length === 0;
+  }
+  if (subcommand === "id") {
+    return hasOnlyOptionFlags(rest, JSON_BOOLEAN_FLAGS, SESSION_ID_VALUE_FLAGS);
+  }
+  return false;
+}
+function isSessionlessCommand(commandTokens) {
+  const normalizedTokens = stripSessionlessShapeGlobalFlags(commandTokens);
+  const command = normalizedTokens.at(0);
+  const subcommand = normalizedTokens.at(1);
+  switch (command) {
+    case void 0:
+      return false;
+    case "skills":
+      return ["list", "get", "path"].includes(subcommand ?? "");
+    case "auth":
+      return isSessionlessAuthCommand(normalizedTokens);
+    case "plugin":
+      return isSessionlessPluginCommand(normalizedTokens);
+    case "mcp":
+      return true;
+    case "dashboard":
+      return isSessionlessDashboardCommand(normalizedTokens);
+    case "device":
+      return normalizedTokens.length === 2 && subcommand === "list";
+    case "doctor":
+      return hasOnlyBooleanFlags(normalizedTokens.slice(1), DOCTOR_BOOLEAN_FLAGS);
+    case "install":
+      return hasOnlyBooleanFlags(normalizedTokens.slice(1), INSTALL_BOOLEAN_FLAGS);
+    case "profiles":
+    case "upgrade":
+      return normalizedTokens.length === 1;
+    case "session":
+      return isSessionlessSessionCommand(normalizedTokens);
+    case "state":
+      return isSessionlessStateCommand(normalizedTokens);
+    default:
+      return false;
+  }
+}
+function isBrowserIndependentRead(commandTokens, stdin) {
+  if (commandTokens[0] !== "batch") {
+    return getExplicitReadUrl(commandTokens) !== void 0;
+  }
+  const steps = getUpstreamEffectiveBatchSteps(commandTokens, stdin);
+  return steps.length > 0 && steps.every((step) => getExplicitReadUrl(step) !== void 0);
+}
+function needsManagedSession(descriptor, stdin) {
+  return !isSessionlessCommand(descriptor.upstreamCommandTokens) && !isBrowserIndependentRead(descriptor.upstreamCommandTokens, stdin);
+}
+
+// dist/extensions/agent-browser/lib/launch-scoped-flags.js
+var LAUNCH_SCOPED_FLAG_DEFINITIONS = [
+  {
+    flag: "--auto-connect",
+    reason: "attaches to an already-running browser at launch time instead of reusing an existing named session"
+  },
+  {
+    flag: "--allowed-domains",
+    reason: "installs upstream network and WebRTC containment on a fresh controllable browser context"
+  },
+  {
+    flag: "--namespace",
+    reason: "selects the upstream daemon/socket and restore-state namespace before session lookup"
+  },
+  {
+    flag: "--cdp",
+    reason: "selects the browser/CDP endpoint used when an upstream session is launched"
+  },
+  {
+    flag: "--ca-cert",
+    reason: "selects isolated Chromium CA trust and may relaunch the browser"
+  },
+  {
+    flag: "--no-ca-cert",
+    reason: "clears retained isolated Chromium CA trust and may relaunch the browser"
+  },
+  {
+    flag: "--enable",
+    reason: "selects built-in page init scripts before the upstream browser session is launched"
+  },
+  {
+    flag: "--engine",
+    reason: "selects the browser engine used for the upstream launch"
+  },
+  {
+    flag: "--executable-path",
+    reason: "selects the browser executable used for the upstream launch"
+  },
+  {
+    flag: "--webgpu",
+    reason: "selects the platform-specific WebGPU browser launch preset"
+  },
+  {
+    flag: "--no-webmcp",
+    reason: "selects whether locally launched Chrome enables experimental WebMCP support"
+  },
+  {
+    flag: "--init-script",
+    reason: "registers page init scripts before the upstream browser session is launched"
+  },
+  {
+    flag: "--idle-timeout",
+    reason: "configures background browser lifecycle for the launched session"
+  },
+  {
+    flag: "--args",
+    reason: "selects raw Chrome arguments for the browser launch"
+  },
+  {
+    flag: "--user-agent",
+    reason: "selects the browser user agent at launch time"
+  },
+  {
+    flag: "--headed",
+    reason: "selects whether the launched browser has a visible window"
+  },
+  {
+    flag: "--device",
+    reason: "selects the provider device for the upstream launch"
+  },
+  {
+    flag: "--profile",
+    reason: "selects Chrome profile state for the upstream launch"
+  },
+  {
+    flag: "--provider",
+    reason: "selects the upstream browser provider for the launch"
+  },
+  {
+    flag: "-p",
+    reason: "selects the upstream browser provider for the launch"
+  },
+  {
+    flag: "--session-name",
+    reason: "selects upstream saved auth/session state for the launch"
+  },
+  {
+    flag: "--restore",
+    reason: "selects upstream saved auth/session restore state for the launch"
+  },
+  {
+    flag: "--restore-save",
+    reason: "configures upstream restore auto-save policy for the launched session"
+  },
+  {
+    flag: "--restore-check-url",
+    reason: "configures restore validation before the launched session can auto-save"
+  },
+  {
+    flag: "--restore-check-text",
+    reason: "configures restore validation before the launched session can auto-save"
+  },
+  {
+    flag: "--restore-check-fn",
+    reason: "configures restore validation before the launched session can auto-save"
+  },
+  {
+    flag: "--state",
+    reason: "loads persisted upstream browser/auth state at launch time"
+  }
+];
+var LAUNCH_SCOPED_FLAGS = LAUNCH_SCOPED_FLAG_DEFINITIONS.map((definition) => definition.flag);
+var LAUNCH_SCOPED_FLAG_LABEL = LAUNCH_SCOPED_FLAGS.join(", ");
+function hasLaunchScopedFlagToken(args, flag) {
+  if (flag === "--restore" && args.some((token) => token.startsWith("--restore="))) {
+    return true;
+  }
+  if (!args.includes(flag)) {
+    return false;
+  }
+  if (flag === "--auto-connect") {
+    return isBooleanFlagEnabled(args, flag);
+  }
+  if (flag !== "--state") {
+    return true;
+  }
+  const commandStartIndex = findCommandStartIndex(args);
+  return commandStartIndex === void 0 || args[commandStartIndex] !== "wait" || args.indexOf(flag) < commandStartIndex;
+}
+
+// dist/extensions/agent-browser/lib/process-environment.js
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// dist/extensions/agent-browser/lib/temp-mutation-queue.js
+var tempMutationQueue = Promise.resolve();
+
+// dist/extensions/agent-browser/lib/process-identity.js
+var PROCESS_START_IDENTITY_TIMEOUT_MS = process.platform === "win32" ? 1e4 : 5e3;
+
+// dist/extensions/agent-browser/lib/temp-root.js
+var STALE_TEMP_ROOT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+
+// dist/extensions/agent-browser/lib/temp-artifact-budget.js
+var DEFAULT_MAX_BYTES = 32 * 1024 * 1024;
+
+// dist/extensions/agent-browser/lib/process-environment.js
+var isolatedAgentBrowserEnvironment = new AsyncLocalStorage();
+var agentBrowserProcessEnvironment = new AsyncLocalStorage();
+var PROXY_ENV_NAMES = /* @__PURE__ */ new Set(["ALL_PROXY", "HTTPS_PROXY", "HTTP_PROXY", "NO_PROXY"]);
+function getAgentBrowserProcessEnvironment(baseEnv = process.env) {
+  const isolatedConfig = isolatedAgentBrowserEnvironment.getStore();
+  if (isolatedConfig === void 0) {
+    return { ...baseEnv, ...agentBrowserProcessEnvironment.getStore()?.env };
+  }
+  return {
+    ...Object.fromEntries(Object.entries(baseEnv).filter(([name]) => {
+      const normalizedName = name.toUpperCase();
+      return !normalizedName.startsWith("AGENT_BROWSER_") && !PROXY_ENV_NAMES.has(normalizedName);
+    })),
+    AGENT_BROWSER_CONFIG: isolatedConfig
+  };
+}
+
+// dist/scripts/agent-browser-target.mjs
+var TARGET_AGENT_BROWSER_VERSION = "0.38.1";
+var TARGET_AGENT_BROWSER_VERSION_LABEL = `agent-browser ${TARGET_AGENT_BROWSER_VERSION}`;
+var MINIMUM_AGENT_BROWSER_VERSION = "0.35.0";
+var MINIMUM_AGENT_BROWSER_VERSION_LABEL = `agent-browser ${MINIMUM_AGENT_BROWSER_VERSION}`;
+var SUPPORTED_AGENT_BROWSER_VERSION_LABEL = `${MINIMUM_AGENT_BROWSER_VERSION_LABEL} or newer`;
+
+// dist/extensions/agent-browser/lib/runtime-args-validation.js
+var INSPECTION_FLAGS = /* @__PURE__ */ new Set(["--help", "-h", "--version", "-V"]);
+var SHELL_OPERATOR_TOKENS = /* @__PURE__ */ new Set(["&&", "||", "|", ";", ">", ">>", "<"]);
+function isPlainTextInspectionArgs(args) {
+  return args.some((token) => INSPECTION_FLAGS.has(token));
+}
+function getSingleKeyCommandValidationError(args) {
+  const { commandInfo, upstreamCommandTokens: tokens } = parseArgvDescriptor(args);
+  const command = commandInfo.command;
+  if (!["press", "key", "keydown", "keyup"].includes(command ?? "") || tokens.length === 2) {
+    return;
+  }
+  const label = command === "key" ? "key/press" : command;
+  return `agent-browser ${label ?? ""} accepts exactly one key argument. Do not pass a selector or ref to ${label ?? ""}; focus or click the target first, then run ${command ?? ""} <key> (for example: focus @e1, then press Enter).`;
+}
+function getBareMcpValidationError(args) {
+  const { commandInfo, upstreamCommandTokens: tokens } = parseArgvDescriptor(args);
+  if (commandInfo.command !== "mcp" || tokens.includes("--help") || tokens.includes("-h")) {
+    return;
+  }
+  return "agent-browser mcp starts a stdio MCP server for external MCP clients, not a one-shot native agent_browser tool workflow. Use the native agent_browser tool modes directly, or configure an MCP client to launch `agent-browser mcp`. Use `mcp --help` for help.";
+}
+function getUnsupportedInlineWaitDownloadError(args) {
+  const descriptor = parseArgvDescriptor(args);
+  if (descriptor.commandInfo.command !== "wait" || !descriptor.upstreamCommandTokens.some((token) => token.startsWith("--download="))) {
+    return;
+  }
+  return `agent-browser ${TARGET_AGENT_BROWSER_VERSION} does not support \`wait --download=<path>\`. Pass the optional path as a separate argument: \`wait --download <path>\` (or \`wait -d <path>\`).`;
+}
+function getBareNoSandboxValidationError(args, batchStep) {
+  const tokens = batchStep ? args : stripUpstreamGlobalFlags(args);
+  const command = tokens[0];
+  const leading = command === "--no-sandbox";
+  if (!leading && (!isOpenNavigationCommand(command) || !tokens.slice(1).includes("--no-sandbox"))) {
+    return;
+  }
+  const explanation = leading ? "`--no-sandbox` is not an agent-browser command." : `\`--no-sandbox\` is ignored as an option by \`${command}\`.`;
+  return `${explanation} It is a Chromium launch argument. Put it in top-level \`--args\` and start a fresh session: { args: ["--args", "--no-sandbox", "open", "https://example.com"], sessionMode: "fresh" }. For batch, put --args before batch, not inside a step.`;
+}
+function getForbiddenToolTokenError(args) {
+  const shellOperator = args.find((token) => SHELL_OPERATOR_TOKENS.has(token));
+  if (shellOperator !== void 0) {
+    return `Do not pass shell operators like \`${shellOperator}\`. Pass exact agent-browser CLI arguments only.`;
+  }
+  if (args.some((token) => token === "--session-mode" || token.startsWith("--session-mode="))) {
+    return 'Do not pass `--session-mode` in args. Use the top-level agent_browser `sessionMode` field instead, for example { args: ["--profile", "Default", "open", "https://example.com"], sessionMode: "fresh" }.';
+  }
+  return;
+}
+function validateToolArgs(args, options = {}) {
+  if (args.length === 0) {
+    return "`args` must contain at least one agent-browser command token.";
+  }
+  const forbidden = getForbiddenToolTokenError(args);
+  if (forbidden !== void 0) {
+    return forbidden;
+  }
+  return getNativeCommandShapeError(args, options.batchStep === true);
+}
+function getNativeCommandShapeError(args, batchStep) {
+  const inspection = !batchStep && isPlainTextInspectionArgs(args);
+  const invalidValueFlag = inspection ? void 0 : getInvalidValueFlagDetails(args, !batchStep);
+  if (invalidValueFlag?.reason === "unsupported-assignment") {
+    return formatInvalidValueFlagError(invalidValueFlag, batchStep);
+  }
+  return (inspection ? void 0 : getBareNoSandboxValidationError(args, batchStep)) ?? getBareMcpValidationError(args) ?? getSingleKeyCommandValidationError(args) ?? getUnsupportedInlineWaitDownloadError(args);
+}
+function unsupportedAssignment(token, flag, allowRestoreAssignment) {
+  return token.includes("=") && (PREVALIDATED_VALUE_FLAGS.has(flag) || GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(flag) || !allowRestoreAssignment && flag === "--restore");
+}
+function valueFlagProblem(flag, receivedToken) {
+  if (receivedToken === void 0 || flag === "--args" && receivedToken.length === 0) {
+    return "missing-value";
+  }
+  if (receivedToken.startsWith("-") && !GLOBAL_VALUE_FLAGS_ALLOWING_DASH_VALUE.has(flag)) {
+    return "unexpected-flag";
+  }
+  return;
+}
+function getInvalidValueFlagDetails(args, allowRestoreAssignment = true) {
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("-")) {
+      continue;
+    }
+    const flag = token.split("=", 1)[0] ?? token;
+    if (unsupportedAssignment(token, flag, allowRestoreAssignment)) {
+      return { flag, index, reason: "unsupported-assignment" };
+    }
+    if (!PREVALIDATED_VALUE_FLAGS.has(flag)) {
+      continue;
+    }
+    const receivedToken = args.at(index + 1);
+    const reason = valueFlagProblem(flag, receivedToken);
+    if (reason !== void 0) {
+      return reason === "unexpected-flag" ? { flag, index, reason, receivedToken } : { flag, index, reason };
+    }
+    index += 1;
+  }
+  return;
+}
+function formatInvalidValueFlagError(details, batchStep = false) {
+  if (details.reason === "unsupported-assignment") {
+    if (batchStep) {
+      return details.flag === "--restore" ? "Global `--restore=<key>` belongs before `batch` in top-level args, not inside a batch step." : `Global \`${details.flag}=<value>\` is not supported inside a batch step. Move \`${details.flag}\` and its value before \`batch\` as separate top-level args.`;
+    }
+    return `agent-browser ${TARGET_AGENT_BROWSER_VERSION} does not support \`${details.flag}=<value>\`. Pass \`${details.flag}\` and its value as separate arguments.`;
+  }
+  if (details.reason === "unexpected-flag" && details.receivedToken !== void 0 && details.receivedToken.length > 0) {
+    return `Flag \`${details.flag}\` requires a value, but received \`${details.receivedToken}\` instead. Pass a non-flag value immediately after \`${details.flag}\`.`;
+  }
+  return `Flag \`${details.flag}\` requires a value immediately after it. Pass a non-flag token like \`${details.flag} demo\`.`;
+}
+
+// dist/extensions/agent-browser/lib/runtime-compatibility.js
+var OPENAI_HOSTS = /* @__PURE__ */ new Set(["chat.com", "chat.openai.com", "chatgpt.com"]);
+var DEFAULT_USER_AGENT_BY_PLATFORM = {
+  darwin: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
+  linux: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
+  win32: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+};
+var FALLBACK_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+function getDefaultHeadlessCompatUserAgent(platform = process.platform) {
+  return DEFAULT_USER_AGENT_BY_PLATFORM[platform] ?? FALLBACK_USER_AGENT;
+}
+function hasLaunchOverride(args, env) {
+  const flags = ["--user-agent", "--args", "--cdp", "--provider", "-p"];
+  return flags.some((flag) => args.some((token) => token === flag || token.startsWith(`${flag}=`))) || [
+    env.AGENT_BROWSER_SESSION,
+    env.AGENT_BROWSER_USER_AGENT,
+    env.AGENT_BROWSER_ARGS,
+    env.AGENT_BROWSER_CDP,
+    env.AGENT_BROWSER_PROVIDER
+  ].some((value) => value !== void 0);
+}
+function hasInteractiveLaunchMode(args, env) {
+  const modes = [
+    ["--headed", env.AGENT_BROWSER_HEADED],
+    ["--auto-connect", env.AGENT_BROWSER_AUTO_CONNECT]
+  ];
+  return modes.some(([flag, value]) => getBooleanFlagValue(args, flag) ?? isUpstreamEnvFlagEnabled(value));
+}
+function canUseHeadlessCompatibilityUserAgent(args, env = getAgentBrowserProcessEnvironment()) {
+  if (hasLaunchOverride(args, env)) {
+    return false;
+  }
+  if (hasInteractiveLaunchMode(args, env)) {
+    return false;
+  }
+  const engine = scanUpstreamGlobalFlagOccurrences(args, "--engine").at(-1)?.value ?? env.AGENT_BROWSER_ENGINE;
+  return (engine ?? "chrome") === "chrome" || engine === "";
+}
+function parseNavigationUrl(url) {
+  if (url === void 0 || url.length === 0) {
+    return;
+  }
+  try {
+    return new URL(url);
+  } catch {
+    try {
+      return new URL(`https://${url}`);
+    } catch {
+      return;
+    }
+  }
+}
+function getCompatibilityWorkaround(args, commandInfo) {
+  if (!isOpenNavigationCommand(commandInfo.command) || !canUseHeadlessCompatibilityUserAgent(args)) {
+    return;
+  }
+  const target = parseNavigationUrl(commandInfo.subcommand);
+  if (!target || !["http:", "https:"].includes(target.protocol)) {
+    return;
+  }
+  const hostname = target.hostname.toLowerCase();
+  if (hostname === "dash.cloudflare.com") {
+    return {
+      id: "cloudflare-headless-user-agent",
+      reason: "Cloudflare Dashboard challenges the default headless Chrome user agent; inject a normal Chrome user agent so authenticated headless browsing reaches the dashboard instead of Turnstile."
+    };
+  }
+  if (!OPENAI_HOSTS.has(hostname)) {
+    return;
+  }
+  return {
+    id: "chatgpt-headless-user-agent",
+    reason: "OpenAI web properties currently challenge the default headless Chrome user agent; inject a normal Chrome user agent to preserve the default headless workflow without requiring headed mode or auto-connect."
+  };
+}
+
+// dist/extensions/agent-browser/lib/runtime-session-plan.js
+function stripExplicitIdentityArgs(args, flag) {
+  const indices = /* @__PURE__ */ new Set();
+  for (const occurrence of scanUpstreamGlobalFlagOccurrences(args, flag)) {
+    indices.add(occurrence.index);
+    indices.add(occurrence.index + 1);
+  }
+  return args.filter((_, index) => !indices.has(index));
+}
+function freshSessionRecoveryHint(args, reason) {
+  return {
+    exampleArgs: args,
+    exampleParams: { args, sessionMode: "fresh" },
+    reason,
+    recommendedSessionMode: "fresh"
+  };
+}
+function launchFlagsRecoveryReason() {
+  return `Launch-scoped flags (${LAUNCH_SCOPED_FLAG_LABEL}) need a fresh upstream launch once the extension-managed session is already active.`;
+}
+function hasExplicitNamespace(args) {
+  return scanUpstreamGlobalFlagOccurrences(args, "--namespace").length > 0;
+}
+function requestedNamespace(args) {
+  return hasExplicitNamespace(args) ? extractExplicitNamespace(args) ?? "" : void 0;
+}
+function nativeNamespace(args) {
+  return resolveAgentBrowserNamespace(args, getAgentBrowserProcessEnvironment().AGENT_BROWSER_NAMESPACE);
+}
+function explicitSessionSelection(args, sessionName, options) {
+  const explicitNamespace = hasExplicitNamespace(args);
+  const managedNamespace = canonicalizeAgentBrowserNamespace(options.managedSessionNamespace);
+  const targetsCurrent = options.managedSessionActive && getAgentBrowserSessionIdentityKey(sessionName, managedNamespace) === getAgentBrowserSessionIdentityKey(options.managedSessionName, managedNamespace);
+  const fallbackNamespace = targetsCurrent ? managedNamespace : nativeNamespace(args);
+  const namespace = explicitNamespace ? requestedNamespace(args) : fallbackNamespace;
+  return {
+    argsToAppend: explicitNamespace ? stripExplicitIdentityArgs(args, "--namespace") : args,
+    prefixArgs: explicitNamespace ? ["--namespace", namespace ?? ""] : [],
+    namespace,
+    sessionName,
+    usedImplicitSession: false
+  };
+}
+function namedManagedSelection(args, identity, implicit, command) {
+  const { namespace, sessionName } = identity;
+  return {
+    argsToAppend: hasExplicitNamespace(args) ? stripExplicitIdentityArgs(args, "--namespace") : args,
+    prefixArgs: [
+      ...namespace === void 0 ? [] : ["--namespace", namespace],
+      "--session",
+      sessionName
+    ],
+    // Empty names retain native namespace reporting without changing the launch prefix.
+    namespace: sessionName.length === 0 && command !== void 0 && !hasExplicitNamespace(args) ? nativeNamespace(args) : namespace,
+    sessionName,
+    managedSessionName: sessionName,
+    usedImplicitSession: implicit
+  };
+}
+function implicitSessionSelection(args, options, command) {
+  if (options.managedSessionActive && command.startupScopedFlags.length > 0) {
+    return {
+      argsToAppend: args,
+      prefixArgs: [],
+      namespace: command.command === void 0 ? requestedNamespace(args) : nativeNamespace(args),
+      usedImplicitSession: false,
+      sessionName: extractExplicitSessionName(args),
+      recoveryHint: freshSessionRecoveryHint(args, launchFlagsRecoveryReason()),
+      validationError: [
+        `The current extension-managed agent-browser session is already running, so launch-scoped flags ${command.startupScopedFlags.join(", ")} would be ignored by upstream agent-browser.`,
+        'Retry this call with `sessionMode: "fresh"` to force a fresh upstream launch, or pass an explicit `--session ...` if you want to name the new session yourself.'
+      ].join(" ")
+    };
+  }
+  const namespace = hasExplicitNamespace(args) ? requestedNamespace(args) : canonicalizeAgentBrowserNamespace(options.managedSessionNamespace);
+  return namedManagedSelection(args, { sessionName: options.managedSessionName, namespace }, true, command.command);
+}
+function unmanagedSessionSelection(args, command) {
+  const explicitNamespace = hasExplicitNamespace(args);
+  const namespace = command !== void 0 && !explicitNamespace ? nativeNamespace(args) : requestedNamespace(args);
+  return {
+    argsToAppend: args,
+    prefixArgs: [],
+    namespace,
+    sessionName: extractExplicitSessionName(args),
+    usedImplicitSession: false
+  };
+}
+function selectExecutionSession(args, options, command) {
+  const explicitSession = extractExplicitSessionName(args);
+  if (explicitSession !== void 0 && explicitSession.length > 0) {
+    return explicitSessionSelection(args, explicitSession, options);
+  }
+  if (command.needsManagedSession) {
+    if (options.sessionMode === "auto") {
+      return implicitSessionSelection(args, options, command);
+    }
+    if (command.command !== void 0 && !isCloseCommand(command.command)) {
+      return namedManagedSelection(args, { sessionName: options.freshSessionName, namespace: requestedNamespace(args) }, false, command.command);
+    }
+  }
+  return unmanagedSessionSelection(args, command.command);
+}
+
+// dist/extensions/agent-browser/lib/redaction-fields.js
+var SENSITIVE_FIELD_NAME_PATTERN = /^(?:[A-Za-z0-9_-]*(?:api[_-]?key|access[_-]?key|private[_-]?key|secret(?:[_-]?(?:key|access[_-]?key))?|token|password|passwd|credentials?|database[_-]?url|db[_-]?url|connection[_-]?string|mongo(?:db)?[_-]?uri|redis[_-]?url)|[A-Za-z0-9]*(?:apiKey|ApiKey|apikey|privateKey|PrivateKey|databaseUrl|DatabaseUrl|dbUrl|DbUrl|connectionString|ConnectionString|mongoUri|MongoUri|mongodbUri|MongodbUri|mongoDbUri|MongoDbUri|redisUrl|RedisUrl|Token|Secret|Password|Credential|Credentials)|auth(?:orization)?|bearer|client(?:_|-)?secret|cookie|id(?:_|-)?token|pass(?:word)?|proxy(?:_|-)?authorization|refresh(?:_|-)?token|sentry(?:_|-)?key|session(?:_|-)?id|set(?:_|-)?cookie|sig(?:nature)?|write(?:_|-)?key|x(?:_|-)?api(?:_|-)?key)$/i;
+var ENV_SECRET_ASSIGNMENT_PATTERN = /\b((?:export\s+)?([A-Za-z_][A-Za-z0-9_-]*)(\s*[:=]\s*))(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;]+)/g;
+function isSensitiveFieldName(key) {
+  SENSITIVE_FIELD_NAME_PATTERN.lastIndex = 0;
+  return SENSITIVE_FIELD_NAME_PATTERN.test(key);
+}
+function isEnvSecretAssignmentKey(key) {
+  if (!isSensitiveFieldName(key)) {
+    return false;
+  }
+  if (key === "password" || key.includes("_") || key.includes("-") || key === key.toUpperCase()) {
+    return true;
+  }
+  return /(?:apiKey|ApiKey|privateKey|PrivateKey|databaseUrl|DatabaseUrl|dbUrl|DbUrl|connectionString|ConnectionString|mongoUri|MongoUri|mongodbUri|MongodbUri|mongoDbUri|MongoDbUri|redisUrl|RedisUrl|Token|Secret|Password|Credential|Credentials)$/.test(key);
+}
+function isLineBoundary(text2, index) {
+  return index < 0 || index >= text2.length || text2[index] === "\n" || text2[index] === "\r";
+}
+function redactPasswordAssignment(text2, match, prefix, offset) {
+  const end = offset + match.length;
+  if (!isLineBoundary(text2, offset - 1) || !isLineBoundary(text2, end) || /^(?:\[REDACTED\]|%5Bredacted%5D)/i.test(match.slice(prefix.length))) {
+    return match;
+  }
+  const value = match.slice(prefix.length);
+  const boundary = value[0] === '"' || value[0] === "'" ? -1 : value.search(/[&#](?=[A-Za-z_][A-Za-z0-9_-]*\s*=)/);
+  return `${prefix}[REDACTED]${boundary < 0 ? "" : value.slice(boundary)}`;
+}
+function redactEnvSecretAssignments(text2) {
+  return text2.replace(
+    ENV_SECRET_ASSIGNMENT_PATTERN,
+    // String.replace supplies match, three captures, then the source offset.
+    (match, prefix, key, _separator, offset) => {
+      if (!isEnvSecretAssignmentKey(key)) {
+        return match;
+      }
+      return key === "password" ? redactPasswordAssignment(text2, match, prefix, offset) : `${prefix}[REDACTED]`;
+    }
+  );
+}
+function credentialTrailingPunctuation(credential) {
+  return credential.match(/[,.:;!?]+$/)?.[0] ?? "";
+}
+function formatRedactedCredential(label, credential, trailing = "") {
+  return `${label} [REDACTED]${credentialTrailingPunctuation(credential)}${trailing}`;
+}
+function redactBearerCredentials(text2) {
+  return text2.replace(
+    /((?:\b([A-Za-z][A-Za-z0-9_-]*)\s*[:=]\s*|(?:^|\s)(?:-H\s*|--header(?:\s+|=)))["']?Bearer)\s+([^\s"',)[\]]+)([),.]?)/gi,
+    // String.replace supplies the match followed by this expression's four captures.
+    (match, label, field, credential, trailing) => {
+      if (field !== void 0 && field.length > 0 && !isSensitiveFieldName(field)) {
+        return match;
+      }
+      return formatRedactedCredential(label, credential, trailing);
+    }
+  ).replace(/\b(Bearer)\s+([^\s\\"',)[\]]+)([),.]?)/gi, (match, label, credential, trailing) => {
+    const token = credential.slice(0, credential.length - credentialTrailingPunctuation(credential).length);
+    if (!/^[A-Za-z0-9._~+/-]+=*$/.test(token) || !/[0-9._~+/=-]/.test(token)) {
+      return match;
+    }
+    return formatRedactedCredential(label, credential, trailing);
+  });
+}
+function redactStandaloneBasicCredential(text2) {
+  return text2.replace(/\b(Basic)\s+([A-Za-z0-9+/=]{12,})/gi, (match, label, credential) => {
+    if (!/[0-9+/=]/.test(credential)) {
+      return match;
+    }
+    return `${label} [REDACTED]`;
+  });
+}
+
+// dist/extensions/agent-browser/lib/redaction-json.js
+function nextQuotePosition(options) {
+  if (options.char === '"') {
+    return options.index;
+  }
+  return options.char === "\\" ? options.quoteAfterNext : options.quoteAtNext;
+}
+function buildJsonBoundaries(text2) {
+  const boundaries = new Int32Array(text2.length + 1).fill(-1);
+  let quoteAtNext = -1;
+  let quoteAfterNext = -1;
+  for (let index = text2.length - 1; index >= 0; index -= 1) {
+    const char = text2[index];
+    switch (char) {
+      case "}":
+      case "]":
+        boundaries[index] = index;
+        break;
+      case '"':
+        boundaries[index] = quoteAtNext < 0 ? -1 : boundaries[quoteAtNext + 1];
+        break;
+      case "{":
+      case "[": {
+        const end = boundaries[index + 1];
+        boundaries[index] = end >= 0 && text2[end] === (char === "{" ? "}" : "]") ? boundaries[end + 1] : -1;
+        break;
+      }
+      default:
+        boundaries[index] = boundaries[index + 1];
+    }
+    const quote = nextQuotePosition({ char, index, quoteAtNext, quoteAfterNext });
+    quoteAfterNext = quoteAtNext;
+    quoteAtNext = quote;
+  }
+  return boundaries;
+}
+function createBalancedJsonEndFinder(text2) {
+  let boundaries;
+  return (startIndex) => {
+    const opener = text2[startIndex];
+    if (opener !== "{" && opener !== "[") {
+      return;
+    }
+    boundaries ??= buildJsonBoundaries(text2);
+    const end = boundaries[startIndex + 1];
+    return end >= 0 && text2[end] === (opener === "{" ? "}" : "]") ? end : void 0;
+  };
+}
+function parseJsonString(token) {
+  const value = JSON.parse(token);
+  if (typeof value !== "string") {
+    throw new Error("Expected a JSON string token");
+  }
+  return value;
+}
+function isSerializedJson(text2) {
+  if (text2 === "[REDACTED]" || !/^\s*[[{"\d\-tfn]/.test(text2)) {
+    return false;
+  }
+  try {
+    JSON.parse(text2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findJsonValueEnd(text2, start, findEnd) {
+  const balancedEnd = findEnd(start);
+  if (balancedEnd !== void 0) {
+    return balancedEnd + 1;
+  }
+  if (text2[start] === '"') {
+    const strings = /"(?:\\.|[^"\\])*"/g;
+    strings.lastIndex = start;
+    const fieldValue = strings.exec(text2);
+    if (fieldValue === null) {
+      throw new Error("Expected a validated JSON string field value");
+    }
+    return parseJsonString(fieldValue[0]) === "[REDACTED]" ? void 0 : strings.lastIndex;
+  }
+  let end = start;
+  while (end < text2.length && !/[\s,\]}]/.test(text2[end])) {
+    end += 1;
+  }
+  return end;
+}
+function redactSerializedJson(text2, redact) {
+  if (!isSerializedJson(text2)) {
+    return;
+  }
+  let output = "";
+  let cursor = 0;
+  const findEnd = createBalancedJsonEndFinder(text2);
+  const strings = /"(?:\\.|[^"\\])*"/g;
+  let match;
+  while ((match = strings.exec(text2)) !== null) {
+    const end = strings.lastIndex;
+    const value = parseJsonString(match[0]);
+    const redacted = redact(value);
+    if (redacted !== value) {
+      output += text2.slice(cursor, match.index) + JSON.stringify(redacted);
+      cursor = end;
+    }
+    const separator = /^\s*:\s*/.exec(text2.slice(end));
+    if (separator === null || !isSensitiveFieldName(value)) {
+      continue;
+    }
+    const valueStart = end + separator[0].length;
+    const valueEnd = findJsonValueEnd(text2, valueStart, findEnd);
+    if (valueEnd === void 0) {
+      strings.lastIndex = valueStart;
+      strings.exec(text2);
+      continue;
+    }
+    output += text2.slice(cursor, valueStart) + '"[REDACTED]"';
+    cursor = valueEnd;
+    strings.lastIndex = valueEnd;
+  }
+  return output + text2.slice(cursor);
+}
+function redactEmbeddedStructuredText(text2, redact) {
+  let output = "";
+  let cursor = 0;
+  const findEnd = createBalancedJsonEndFinder(text2);
+  const openers = /[[{]/g;
+  let match;
+  while ((match = openers.exec(text2)) !== null) {
+    const endIndex = findEnd(match.index);
+    if (endIndex === void 0) {
+      continue;
+    }
+    const candidate = text2.slice(match.index, endIndex + 1);
+    const redacted = redactSerializedJson(candidate, redact) ?? candidate;
+    if (redacted !== candidate) {
+      output += text2.slice(cursor, match.index) + redacted;
+      cursor = endIndex + 1;
+    }
+    openers.lastIndex = endIndex + 1;
+  }
+  return cursor === 0 ? text2 : output + text2.slice(cursor);
+}
+
+// dist/extensions/agent-browser/lib/redaction-url.js
+var SENSITIVE_QUERY_PARAM_PATTERN = /^(?:access(?:_|-)?token|api(?:_|-)?key|auth|authorization|authorization(?:_|-)?session(?:_|-)?id|bearer|client(?:_|-)?secret|code|cookie|id(?:_|-)?token|key|pass(?:word)?|refresh(?:_|-)?token|relay(?:_|-)?state|saml(?:_|-)?request|saml(?:_|-)?response|secret|sentry(?:_|-)?key|session(?:_|-)?id|sig(?:nature)?|token|write(?:_|-)?key)$/i;
+var AUTH_STATE_QUERY_PARAM_PATTERN = /^(?:nonce|state)$/i;
+var AUTH_URL_CONTEXT_PATTERN = /(?:^|[./_-])(?:auth|authorize|callback|login|oauth2?|oidc|saml|sso)(?:[./?#_-]|$)/i;
+function shouldRedactQueryParam(name) {
+  return SENSITIVE_QUERY_PARAM_PATTERN.test(name) || isSensitiveFieldName(name);
+}
+function isSensitiveParameter(name, authContext) {
+  return shouldRedactQueryParam(name) || authContext && AUTH_STATE_QUERY_PARAM_PATTERN.test(name);
+}
+function redactParameters(params, authContext) {
+  let mutated = false;
+  for (const [name] of params) {
+    if (isSensitiveParameter(name, authContext)) {
+      params.set(name, "[REDACTED]");
+      mutated = true;
+    }
+  }
+  return mutated;
+}
+function getHashParameters(hash) {
+  const text2 = hash.startsWith("#") ? hash.slice(1) : hash;
+  return text2.includes("=") ? new URLSearchParams(text2) : void 0;
+}
+function redactUrlToken(token) {
+  let parsed;
+  try {
+    parsed = new URL(token);
+  } catch {
+    return token;
+  }
+  const originalHref = parsed.href;
+  if (parsed.username.length > 0) {
+    parsed.username = "[REDACTED]";
+  }
+  if (parsed.password.length > 0) {
+    parsed.password = "[REDACTED]";
+  }
+  const hashParams = getHashParameters(parsed.hash);
+  const authContext = AUTH_URL_CONTEXT_PATTERN.test(`${parsed.hostname}${parsed.pathname}`) || [...parsed.searchParams.keys(), ...hashParams?.keys() ?? []].some(shouldRedactQueryParam);
+  redactParameters(parsed.searchParams, authContext);
+  if (hashParams && redactParameters(hashParams, authContext)) {
+    parsed.hash = `#${hashParams.toString()}`;
+  }
+  return parsed.href === originalHref ? token : parsed.href;
+}
+function decodeParameterName(raw) {
+  try {
+    return decodeURIComponent(raw.replace(/\+/g, " "));
+  } catch {
+    return raw;
+  }
+}
+function redactLooseUrlParameterText(text2) {
+  return text2.replace(/(?<![^\s"'`<>\])}])[^\s"'`<>\])}]*[?#&][^\s"'`<>\])}]*/g, (token) => {
+    const queryNames = [...token.matchAll(/[?#&]([^=&#\s"'`<>\])}]+)=/g)].map((match) => decodeParameterName(match[1]));
+    const authContext = AUTH_URL_CONTEXT_PATTERN.test(token) || queryNames.some(shouldRedactQueryParam);
+    return token.replace(/([?#&])([^=&#\s"'`<>\])}]+)=([^&#\s"'`<>\])}]*)/g, (match, separator, rawName, rawValue) => {
+      if (rawValue === "[REDACTED" || rawValue === "[REDACTED]" || /%5Bredacted%5D/i.test(rawValue)) {
+        return match;
+      }
+      if (!isSensitiveParameter(decodeParameterName(rawName), authContext)) {
+        return match;
+      }
+      return `${separator}${rawName}=[REDACTED]`;
+    });
+  });
+}
+function redactLooseUrlUserinfo(text2) {
+  return text2.replace(/\b([A-Za-z][A-Za-z0-9+.-]*:\/\/)([^\s"'`/@]+)@([^\s"'`]+)/g, (match, prefix, userinfo, suffix) => {
+    if (/%5Bredacted%5D/i.test(userinfo)) {
+      return match;
+    }
+    if (userinfo.includes("[REDACTED]")) {
+      return redactLooseUrlParameterText(match);
+    }
+    return redactLooseUrlParameterText(`${prefix}${userinfo.includes(":") ? "[REDACTED]:[REDACTED]" : "[REDACTED]"}@${suffix}`);
+  });
+}
+function redactLooseUrls(text2) {
+  const urls = text2.replace(/\b[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s"'`<>\])]+/g, (match) => redactUrlToken(match));
+  return redactLooseUrlParameterText(redactLooseUrlUserinfo(urls));
+}
+
+// dist/extensions/agent-browser/lib/runtime-redaction.js
+var SENSITIVE_VALUE_FLAGS = /* @__PURE__ */ new Set(["--body", "--headers", "--password", "--proxy"]);
+function redactSensitiveText(text2) {
+  const serialized = redactSerializedJson(text2, redactSensitiveText);
+  if (serialized !== void 0) {
+    return serialized;
+  }
+  const embedded = redactEmbeddedStructuredText(text2, redactSensitiveText);
+  const credentials = redactStandaloneBasicCredential(redactBearerCredentials(redactLooseUrls(embedded))).replace(/\b(Authorization\s*:\s*Basic)\s+[^\s",]+/gi, "$1 [REDACTED]").replace(/\b(Cookie|Set-Cookie)\s*:\s*[^\n\r"]+/gi, "$1: [REDACTED]");
+  return redactEmbeddedStructuredText(redactEnvSecretAssignments(credentials), redactSensitiveText);
+}
+function redactSensitiveValue(value) {
+  if (typeof value === "string") {
+    return redactSensitiveText(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactSensitiveValue(item));
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [
+    key,
+    isSensitiveFieldName(key) ? "[REDACTED]" : redactSensitiveValue(entryValue)
+  ]));
+}
+function redactFlagTokens(args) {
+  const redacted = [];
+  let pendingValueFlag;
+  for (const token of args) {
+    if (pendingValueFlag !== void 0) {
+      redacted.push(SENSITIVE_VALUE_FLAGS.has(pendingValueFlag) ? "[REDACTED]" : redactUrlToken(token));
+      pendingValueFlag = void 0;
+      continue;
+    }
+    const normalizedToken = token.split("=", 1)[0] ?? token;
+    if (SENSITIVE_VALUE_FLAGS.has(normalizedToken)) {
+      if (token.includes("=")) {
+        redacted.push(`${normalizedToken}=[REDACTED]`);
+      } else {
+        redacted.push(token);
+        pendingValueFlag = normalizedToken;
+      }
+      continue;
+    }
+    redacted.push(redactSensitiveText(redactUrlToken(token)));
+  }
+  return redacted;
+}
+function sensitiveOperandIndices(args, start) {
+  const command = args[start];
+  const subcommand = args[start + 1];
+  switch (command) {
+    case "set":
+      return subcommand === "credentials" ? [start + 2, start + 3] : [];
+    case "cookies":
+      return subcommand === "set" && !extractUpstreamCommandTokens(args).slice(2).includes("--curl") ? [start + 3] : [];
+    case "storage":
+      return ["local", "session"].includes(subcommand) && args[start + 2] === "set" ? [start + 4] : [];
+    case "clipboard":
+      return subcommand === "write" ? args.slice(start + 2).map((_, index) => start + 2 + index) : [];
+    default:
+      return [];
+  }
+}
+function redactBatchRows(args) {
+  const batch = projectUpstreamGlobalFlags(args);
+  const replacements = /* @__PURE__ */ new Map();
+  if (batch.tokens[0] !== "batch") {
+    return replacements;
+  }
+  for (let index = 1; index < batch.tokens.length; index++) {
+    if (batch.tokens[index] === "--bail") {
+      continue;
+    }
+    const step = parseBatchCommandArgument(batch.tokens[index]).step;
+    if (!step) {
+      continue;
+    }
+    const safe = redactInvocationArgs(step);
+    if (safe.some((token, offset) => token !== step[offset])) {
+      replacements.set(batch.indices[index], safe.map((token) => `'${token.replaceAll("'", "'\\''")}'`).join(" "));
+    }
+  }
+  return replacements;
+}
+function redactInvocationArgs(args) {
+  const redacted = redactFlagTokens(args);
+  const start = findCommandStartIndex(args);
+  if (start !== void 0) {
+    for (const index of sensitiveOperandIndices(args, start)) {
+      if (index < redacted.length) {
+        redacted[index] = "[REDACTED]";
+      }
+    }
+  }
+  for (const [index, replacement] of redactBatchRows(args)) {
+    redacted[index] = replacement;
+  }
+  return redacted;
+}
+
+// dist/extensions/agent-browser/lib/runtime-timeouts.js
+var DEFAULT_IMPLICIT_SESSION_IDLE_TIMEOUT_MS = 15 * 60 * 1e3;
+var DEFAULT_IMPLICIT_SESSION_CLOSE_TIMEOUT_MS = 35e3;
+function parseTimeoutMs(rawValue, minimumValue) {
+  if (rawValue === void 0) {
+    return;
+  }
+  const normalizedValue = rawValue.trim();
+  if (!/^\d+$/.test(normalizedValue)) {
+    return;
+  }
+  const parsedValue = Number(normalizedValue);
+  if (!Number.isSafeInteger(parsedValue) || parsedValue < minimumValue) {
+    return;
+  }
+  return parsedValue;
+}
+function getImplicitSessionIdleTimeoutMs(env = getAgentBrowserProcessEnvironment()) {
+  return parseTimeoutMs(env.PI_AGENT_BROWSER_IMPLICIT_SESSION_IDLE_TIMEOUT_MS, 0) ?? parseTimeoutMs(env.AGENT_BROWSER_IDLE_TIMEOUT_MS, 0) ?? DEFAULT_IMPLICIT_SESSION_IDLE_TIMEOUT_MS;
+}
+function getImplicitSessionCloseTimeoutMs(env = getAgentBrowserProcessEnvironment()) {
+  return parseTimeoutMs(env.PI_AGENT_BROWSER_IMPLICIT_SESSION_CLOSE_TIMEOUT_MS, 0) ?? DEFAULT_IMPLICIT_SESSION_CLOSE_TIMEOUT_MS;
+}
+
+// dist/extensions/agent-browser/lib/runtime-session-identity.js
+import { createHash, randomUUID } from "node:crypto";
+import { basename } from "node:path";
+
+// dist/extensions/agent-browser/lib/owned-managed-session-context.js
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var ownedManagedSessionStorage = new AsyncLocalStorage2();
+
+// dist/extensions/agent-browser/lib/managed-session-snapshot-records.js
+var OWNED_RESTORE_SNAPSHOT_RECORD_MAX_BYTES = 16 * 1024;
+var OWNED_RESTORE_SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+
+// dist/extensions/agent-browser/lib/managed-session-restore.js
+var MANAGED_SESSION_NAME_PREFIX = "piab-";
+
+// dist/extensions/agent-browser/lib/runtime-session-identity.js
+function namespaceFields(namespace) {
+  return namespace === void 0 ? {} : { namespace };
+}
+function resolveManagedSessionState(options) {
+  const { command, managedSessionName, priorActive, priorSessionName, succeeded } = options;
+  const managedNamespace = canonicalizeAgentBrowserNamespace(options.managedSessionNamespace);
+  const priorNamespace = canonicalizeAgentBrowserNamespace(options.priorNamespace);
+  const priorState = {
+    active: priorActive,
+    ...namespaceFields(priorNamespace),
+    sessionName: priorSessionName
+  };
+  if (managedSessionName === void 0 || managedSessionName.length === 0) {
+    return priorState;
+  }
+  if (isCloseCommand(command) && managedSessionName === priorSessionName) {
+    if (managedNamespace !== priorNamespace || !succeeded) {
+      return priorState;
+    }
+    return { active: false, sessionName: priorSessionName };
+  }
+  if (!succeeded) {
+    return priorState;
+  }
+  return {
+    active: true,
+    ...namespaceFields(managedNamespace),
+    replacedSessionName: priorActive && priorSessionName !== managedSessionName ? priorSessionName : void 0,
+    sessionName: managedSessionName
+  };
+}
+function isRestorableManagedSessionName(sessionName, fallbackSessionName) {
+  return sessionName === fallbackSessionName || sessionName.startsWith(`${fallbackSessionName}-fresh-`);
+}
+function getRestorableManagedSessionName(value, fallbackSessionName) {
+  return typeof value === "string" && isRestorableManagedSessionName(value, fallbackSessionName) ? value : void 0;
+}
+function createEphemeralSessionSeed() {
+  return randomUUID();
+}
+function createImplicitSessionName(sessionId, cwd, ephemeralSeed, platform = process.platform) {
+  const normalizedSessionId = sessionId?.replaceAll("-", "").toLowerCase();
+  const identity = normalizedSessionId !== void 0 && normalizedSessionId.length > 0 ? `session:${normalizedSessionId}:cwd:${cwd}` : `ephemeral:${cwd}:${ephemeralSeed}`;
+  if (platform === "android") {
+    return `${MANAGED_SESSION_NAME_PREFIX}${createHash("sha256").update(identity).digest("hex").slice(0, 20)}`;
+  }
+  const projectSlug = basename(cwd).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+  const slug = projectSlug.length > 0 ? projectSlug : "project";
+  const cwdHash = createHash("sha256").update(`cwd:${cwd}`).digest("hex").slice(0, 8);
+  const sessionIdentity = normalizedSessionId !== void 0 && normalizedSessionId.length > 0 ? `session:${normalizedSessionId}` : identity;
+  const digest = createHash("sha256").update(sessionIdentity).digest("hex").slice(0, 12);
+  return `${MANAGED_SESSION_NAME_PREFIX}${slug}-${digest}-${cwdHash}`;
+}
+function createFreshSessionName(baseSessionName, ephemeralSeed, ordinal) {
+  const suffix = createHash("sha256").update(`fresh:${baseSessionName}:${ephemeralSeed}:${ordinal}`).digest("hex").slice(0, 10);
+  return `${baseSessionName}-fresh-${suffix}`;
+}
+
+// dist/extensions/agent-browser/lib/page-target-navigation.js
+var POSITIONAL_VALUE_FLAGS = /* @__PURE__ */ new Set([...VALUE_FLAGS, "--llms"]);
+
+// dist/extensions/agent-browser/lib/native-confirmation.js
+function isSuccessfulNativeConfirmedClose(commandTokens, data) {
+  if (commandTokens[0] !== "confirm" || commandTokens.length !== 2 || !isRecord(data) || data.confirmed !== true || data.action !== "close") {
+    return false;
+  }
+  return isRecord(data.result) && data.result.success === true && isRecord(data.result.data) && data.result.data.closed === true;
+}
+
+// dist/extensions/agent-browser/lib/results/confirmation.js
+var CONFIRMATION_REQUIRED_FIELD_NAMES = [
+  "confirmation_required",
+  "confirmationRequired",
+  "requires_confirmation",
+  "requiresConfirmation"
+];
+var CONFIRMATION_REQUIRED_RECORD_FIELD_NAMES = [
+  "confirmation",
+  "pendingConfirmation",
+  "pending_confirmation"
+];
+var CONFIRMATION_ID_FIELD_NAMES = ["confirmation_id", "confirmationId", "id"];
+var CONFIRMATION_ACTION_TEXT_FIELD_NAMES = [
+  "action",
+  "description",
+  "message",
+  "summary"
+];
+var CONFIRMATION_REQUIRED_MARKER = "confirmation_required";
+function getTrimmedStringField(data, fieldNames) {
+  for (const fieldName of fieldNames) {
+    const value = data[fieldName];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function hasConfirmationRequiredMarker(data) {
+  return CONFIRMATION_REQUIRED_FIELD_NAMES.some((fieldName) => data[fieldName] === true) || data.type === CONFIRMATION_REQUIRED_MARKER || data.status === CONFIRMATION_REQUIRED_MARKER || data.kind === CONFIRMATION_REQUIRED_MARKER;
+}
+function getNestedConfirmationRecord(data) {
+  for (const fieldName of CONFIRMATION_REQUIRED_RECORD_FIELD_NAMES) {
+    const value = data[fieldName];
+    if (isRecord(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function getConfirmationPayload(data) {
+  return isRecord(data) && data.confirmed === true && isRecord(data.result) && data.result.success === true ? data.result.data : data;
+}
+function detectConfirmationRequired(data) {
+  const payload = getConfirmationPayload(data);
+  if (!isRecord(payload)) {
+    return void 0;
+  }
+  const nestedRecord = getNestedConfirmationRecord(payload);
+  const candidateRecords = nestedRecord ? [payload, nestedRecord] : [payload];
+  if (!candidateRecords.some(hasConfirmationRequiredMarker)) {
+    return void 0;
+  }
+  for (const record of candidateRecords) {
+    const id = getTrimmedStringField(record, CONFIRMATION_ID_FIELD_NAMES);
+    if (id === void 0 || id.length === 0) {
+      continue;
+    }
+    return {
+      actionText: getTrimmedStringField(record, CONFIRMATION_ACTION_TEXT_FIELD_NAMES),
+      id
+    };
+  }
+  return void 0;
+}
+
+// dist/extensions/agent-browser/lib/batch-lifecycle.js
+function rowCommand(value, fallback) {
+  return Array.isArray(value) && value.every((token) => typeof token === "string") ? value : fallback;
+}
+function rowResult(row) {
+  if (isRecord(row.result)) {
+    return row.result;
+  }
+  return isRecord(row.data) ? row.data : void 0;
+}
+function rowBrowserLaunched(row, result) {
+  const lifecycle = isRecord(row.lifecycle) ? row.lifecycle : result?.lifecycle;
+  if (!isRecord(lifecycle) || !isRecord(lifecycle.effectiveLaunch)) {
+    return void 0;
+  }
+  const launched = lifecycle.effectiveLaunch.browserLaunched;
+  return typeof launched === "boolean" ? launched : void 0;
+}
+function lifecycleStep(value, fallback) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const result = rowResult(value);
+  const command = rowCommand(value.command, fallback);
+  return {
+    result,
+    succeeded: value.success === true,
+    browserLaunched: rowBrowserLaunched(value, result),
+    tokens: command === void 0 ? void 0 : extractUpstreamCommandTokens(command)
+  };
+}
+function batchHasSuccessfulCloseAll(data, fallbackCommands = []) {
+  if (!Array.isArray(data)) {
+    return false;
+  }
+  return data.some((row, index) => {
+    if (!isRecord(row) || row.success !== true) {
+      return false;
+    }
+    const command = rowCommand(row.command, fallbackCommands.at(index));
+    return command !== void 0 && !detectConfirmationRequired(row.result) && isCloseAllCommand(extractUpstreamCommandTokens(command));
+  });
+}
+function successfulClose(step) {
+  return step.succeeded && step.tokens !== void 0 && !detectConfirmationRequired(step.result) && (isCloseCommand(step.tokens[0]) || isSuccessfulNativeConfirmedClose(step.tokens, step.result));
+}
+function closedState(step) {
+  const result = step.result;
+  const closeData = step.tokens?.[0] === "confirm" && isRecord(result) && isRecord(result.result) ? result.result.data : result;
+  return {
+    endsClosed: true,
+    browserActiveAfterClose: false,
+    recordingClosedAfterBatch: true,
+    statePath: isRecord(closeData) && typeof closeData.statePath === "string" ? closeData.statePath : void 0
+  };
+}
+function recordingState(state, step) {
+  const relaunched = step.browserLaunched !== false;
+  const browserActiveAfterClose = state.browserActiveAfterClose || relaunched;
+  let recordingClosedAfterBatch = state.recordingClosedAfterBatch;
+  const subcommand = step.tokens?.[1];
+  if (step.succeeded && subcommand === "stop") {
+    recordingClosedAfterBatch = true;
+  } else if (step.succeeded && browserActiveAfterClose && (subcommand === "start" || subcommand === "restart")) {
+    recordingClosedAfterBatch = false;
+  }
+  return {
+    ...state,
+    endsClosed: state.endsClosed && !relaunched,
+    browserActiveAfterClose,
+    recordingClosedAfterBatch
+  };
+}
+function advanceClosedState(state, step) {
+  if (step.tokens?.[0] === "record") {
+    return recordingState(state, step);
+  }
+  if (step.browserLaunched === false) {
+    return state;
+  }
+  return {
+    ...state,
+    endsClosed: false,
+    browserActiveAfterClose: true,
+    recordingClosedAfterBatch: step.tokens === void 0 ? false : state.recordingClosedAfterBatch
+  };
+}
+function getSuccessfulBatchCloseLifecycle(rows, fallbackCommands = []) {
+  if (!Array.isArray(rows)) {
+    return void 0;
+  }
+  let state;
+  for (const [index, row] of rows.entries()) {
+    const step = lifecycleStep(row, fallbackCommands.at(index));
+    if (step === void 0) {
+      continue;
+    }
+    if (successfulClose(step)) {
+      state = closedState(step);
+    } else if (state !== void 0) {
+      state = advanceClosedState(state, step);
+    }
+  }
+  return state === void 0 ? void 0 : {
+    endsClosed: state.endsClosed,
+    recordingClosedAfterBatch: state.recordingClosedAfterBatch,
+    statePath: state.statePath
+  };
+}
+
+// dist/extensions/agent-browser/lib/browser-value-parsing.js
+function isBrowserStringArray(value) {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  const rows = value;
+  return rows.every((row) => typeof row === "string");
+}
+
+// dist/extensions/agent-browser/lib/session-page-observation.js
+function normalizeComparableUrl(url) {
+  const normalizedUrl = url?.trim();
+  if (normalizedUrl === void 0 || normalizedUrl.length === 0) {
+    return void 0;
+  }
+  try {
+    const parsedUrl = new URL(normalizedUrl);
+    parsedUrl.hash = "";
+    return parsedUrl.toString();
+  } catch {
+    return void 0;
+  }
+}
+function trimmedOptionalValue(value) {
+  const trimmed = value?.trim();
+  return trimmed !== void 0 && trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeSessionTabTarget(target) {
+  if (!target) {
+    return void 0;
+  }
+  const url = trimmedOptionalValue(target.url);
+  if (url === void 0 || normalizeComparableUrl(url) === void 0) {
+    return void 0;
+  }
+  const targetId = trimmedOptionalValue(target.targetId);
+  return {
+    ...targetId !== void 0 ? { targetId } : {},
+    title: trimmedOptionalValue(target.title),
+    url
+  };
+}
+
+// dist/extensions/agent-browser/lib/results/artifact-manifest-validation.js
+function finiteNonnegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function safeCount(value) {
+  return finiteNonnegative(value) && Number.isSafeInteger(value);
+}
+function optionalStrings(value, keys) {
+  return keys.every((key) => value[key] === void 0 || typeof value[key] === "string");
+}
+function nullableStrings(value, keys) {
+  return keys.every((key) => value[key] === null || typeof value[key] === "string");
+}
+function nullableNumbers(value, keys) {
+  return keys.every((key) => value[key] === null || finiteNonnegative(value[key]));
+}
+function nullableBoolean(value) {
+  return value === null || typeof value === "boolean";
+}
+function captureIsValid(value) {
+  return nullableStrings(value, [
+    "startedAt",
+    "endedAt",
+    "firstFrameAt",
+    "lastFrameAt",
+    "timestampSource"
+  ]) && nullableNumbers(value, [
+    "durationMs",
+    "firstFrameAfterMs",
+    "lastFrameAfterMs",
+    "averageFps",
+    "maxFrameGapMs"
+  ]);
+}
+function outputIsValid(value) {
+  return nullableStrings(value, ["durationSource"]) && nullableNumbers(value, [
+    "frames",
+    "fps",
+    "encodedFrames",
+    "durationMs",
+    "heldFrames",
+    "droppedFrames",
+    "skippedFrames"
+  ]) && nullableBoolean(value.encoderSucceeded);
+}
+function recordingIsValid(value) {
+  if (!isRecord(value) || !isRecord(value.capture) || !isRecord(value.output) || !isRecord(value.file)) {
+    return false;
+  }
+  return recordingScalarsAreValid(value) && captureIsValid(value.capture) && outputIsValid(value.output) && nullableBoolean(value.file.exists) && nullableNumbers(value.file, ["sizeBytes"]);
+}
+function recordingScalarsAreValid(value) {
+  return typeof value.warning === "string" && typeof value.path === "string" && nullableStrings(value, ["recordingId", "error"]) && nullableBoolean(value.success) && nullableNumbers(value, ["frames", "capturedFrames", "fps"]);
+}
+function optionalNumbersAreValid(value) {
+  return ["evictedAtMs", "recordingStartedAtMs"].every((key) => value[key] === void 0 || typeof value[key] === "number" && Number.isFinite(value[key])) && (value.sizeBytes === void 0 || finiteNonnegative(value.sizeBytes));
+}
+function optionalRecordingIsValid(value) {
+  return (value.recordingState === void 0 || value.recordingState === "openRecording") && (value.recording === void 0 || recordingIsValid(value.recording)) && (value.status === void 0 || [
+    "failed",
+    "missing",
+    "pending",
+    "repaired-from-temp",
+    "saved",
+    "stale",
+    "unverified",
+    "upstream-temp-only"
+  ].some((status) => status === value.status));
+}
+function optionalEvidenceIsValid(value) {
+  return optionalStrings(value, [
+    "absolutePath",
+    "command",
+    "cwd",
+    "extension",
+    "mediaType",
+    "namespace",
+    "requestedPath",
+    "session",
+    "subcommand"
+  ]) && (value.exists === void 0 || typeof value.exists === "boolean") && optionalNumbersAreValid(value) && optionalRecordingIsValid(value);
+}
+function isManifestEntry(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.path === "string" && value.path.trim().length > 0 && typeof value.createdAtMs === "number" && Number.isFinite(value.createdAtMs) && ["evicted", "ephemeral", "live", "missing"].some((state) => state === value.retentionState) && ["explicit-path", "persistent-session", "process-temp"].some((scope) => scope === value.storageScope) && ["download", "file", "har", "image", "pdf", "profile", "trace", "video", "spill"].some((kind) => kind === value.kind) && optionalEvidenceIsValid(value);
+}
+function manifestCountsAreValid(value) {
+  return safeCount(value.maxEntries) && value.maxEntries !== 0 && safeCount(value.liveCount) && safeCount(value.evictedCount);
+}
+function isSessionArtifactManifest(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.version === 1 && Array.isArray(value.entries) && value.entries.every(isManifestEntry) && typeof value.updatedAtMs === "number" && Number.isFinite(value.updatedAtMs) && manifestCountsAreValid(value);
+}
+
+// dist/extensions/agent-browser/lib/browser-transcript-contracts.js
+var BROWSER_TRANSITION_ENTRY = "agent-browser-transition";
+
+// dist/extensions/agent-browser/lib/browser-transcript-validation.js
+function invalidEvent() {
+  throw new Error("Invalid browser event; inspect or convert the retained session before browser work.");
+}
+function invalidPage() {
+  throw new Error("Invalid browser page disposition; refs cannot be restored.");
+}
+function parseInvalidation(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value) || value.reason !== "page-transition" && value.reason !== "no-active-page" || typeof value.summary !== "string") {
+    return invalidPage();
+  }
+  return { ...value, reason: value.reason, summary: value.summary };
+}
+function parseRefs(value) {
+  if (!isRecord(value)) {
+    return invalidPage();
+  }
+  if (value.kind === "reuse" || value.kind === "replace") {
+    if (typeof value.snapshotId !== "string" || value.snapshotId.length === 0) {
+      return invalidPage();
+    }
+    return { ...value, kind: value.kind, snapshotId: value.snapshotId };
+  }
+  if (value.kind !== "unknown" && value.kind !== "invalidate") {
+    return invalidPage();
+  }
+  const invalidation = parseInvalidation(value.invalidation);
+  return { ...value, kind: value.kind, ...invalidation ? { invalidation } : {} };
+}
+function decodeBrowserTarget(value) {
+  if (!isRecord(value) || typeof value.url !== "string") {
+    return void 0;
+  }
+  if (value.title !== void 0 && typeof value.title !== "string" || value.targetId !== void 0 && typeof value.targetId !== "string") {
+    return void 0;
+  }
+  const target = { ...value, url: value.url };
+  return normalizeSessionTabTarget(target) === void 0 ? void 0 : target;
+}
+function parseBrowserTarget(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return decodeBrowserTarget(value) ?? invalidPage();
+}
+function pageScalarsValid(value) {
+  return (value.confirmActions === void 0 || value.confirmActions === null || typeof value.confirmActions === "string") && (value.unknown === void 0 || value.unknown === true) && (value.clear === void 0 || value.clear === true);
+}
+function pagePolicyValid(value) {
+  return (value.reopenPending === void 0 || typeof value.reopenPending === "boolean") && (value.pinningReason === void 0 || value.pinningReason === "restore" || value.pinningReason === "drift");
+}
+function parsePage(value) {
+  if (!isRecord(value) || typeof value.key !== "string" || !pageScalarsValid(value) || !pagePolicyValid(value)) {
+    return invalidPage();
+  }
+  const target = parseBrowserTarget(value.target);
+  return { ...value, key: value.key, refs: parseRefs(value.refs), ...target ? { target } : {} };
+}
+function parsePages(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    return invalidPage();
+  }
+  const pages = value;
+  return pages.map(parsePage);
+}
+function parseArtifacts(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isRecord(value) || !isBrowserStringArray(value.removals)) {
+    throw new Error("Invalid browser artifact changes; inspect the retained journal.");
+  }
+  const manifest = {
+    version: 1,
+    entries: value.upserts,
+    maxEntries: value.maxEntries,
+    updatedAtMs: value.updatedAtMs,
+    liveCount: 0,
+    evictedCount: 0
+  };
+  if (!isSessionArtifactManifest(manifest)) {
+    throw new Error("Invalid browser artifact changes; inspect the retained journal.");
+  }
+  return {
+    ...value,
+    upserts: manifest.entries,
+    removals: value.removals,
+    maxEntries: manifest.maxEntries,
+    updatedAtMs: manifest.updatedAtMs
+  };
+}
+function eventIdentity(value) {
+  if (typeof value.operationId !== "string" || typeof value.toolCallId !== "string" || typeof value.commandIndex !== "number" || !Number.isSafeInteger(value.commandIndex) || value.commandIndex < 0 || typeof value.isError !== "boolean") {
+    return invalidEvent();
+  }
+  return {
+    operationId: value.operationId,
+    toolCallId: value.toolCallId,
+    commandIndex: value.commandIndex,
+    isError: value.isError
+  };
+}
+function parseBrowserEvent(value) {
+  const phase = value.phase;
+  if (phase !== "begin" && phase !== "finish" && phase !== "state") {
+    return invalidEvent();
+  }
+  if (!isRecord(value.state)) {
+    return invalidEvent();
+  }
+  const identity = eventIdentity(value);
+  const pages = parsePages(value.pages);
+  const artifacts = parseArtifacts(value.artifacts);
+  return {
+    ...value,
+    ...identity,
+    version: 1,
+    phase,
+    state: value.state,
+    ...pages ? { pages } : {},
+    ...artifacts ? { artifacts } : {}
+  };
+}
+
+// dist/extensions/agent-browser/lib/browser-transcript.js
+var BROWSER_EVENT_VERSION = 1;
+function getBrowserRecord(entry) {
+  if (!isRecord(entry) || !isRecord(entry.data)) {
+    return void 0;
+  }
+  if (entry.type !== "message" && !(entry.type === "custom" && entry.customType === BROWSER_TRANSITION_ENTRY)) {
+    return void 0;
+  }
+  const event = entry.data.event;
+  if (!isRecord(event) || event.version !== BROWSER_EVENT_VERSION) {
+    return void 0;
+  }
+  return { ...entry.data, event: parseBrowserEvent(event) };
+}
+function getBrowserResultMessage(entry) {
+  const record = getBrowserRecord(entry);
+  return record ? {
+    details: record.event.state,
+    isError: typeof record.event.state.nativeSucceeded === "boolean" ? !record.event.state.nativeSucceeded : record.event.isError
+  } : void 0;
+}
+
+// dist/extensions/agent-browser/lib/runtime-replay-events.js
+function text(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function cleanupSession(step, record, fallbackNamespace, fallbackSessionName) {
+  if (!isRecord(step) || step.resource !== "managed-session" || step.state !== "removed" && step.state !== "already-gone") {
+    return;
+  }
+  const sessionName = getRestorableManagedSessionName(step.sessionName, fallbackSessionName) ?? getRestorableManagedSessionName(record?.sessionName, fallbackSessionName);
+  if (sessionName === void 0 || sessionName.length === 0) {
+    return;
+  }
+  return { namespace: text(step.namespace) ?? fallbackNamespace, sessionName };
+}
+function cleanupSessionsForResult(result, detailsNamespace, fallbackSessionName) {
+  if (!isRecord(result) || !Array.isArray(result.steps)) {
+    return [];
+  }
+  const record = isRecord(result.record) ? result.record : void 0;
+  const namespace = text(record?.namespace) ?? detailsNamespace;
+  const closedSessions = [];
+  for (const step of result.steps) {
+    const identity = cleanupSession(step, record, namespace, fallbackSessionName);
+    if (identity) {
+      closedSessions.push(identity);
+    }
+  }
+  return closedSessions;
+}
+function getElectronCleanupClosedManagedSessions(details, fallbackSessionName) {
+  const electron = isRecord(details.electron) ? details.electron : void 0;
+  const cleanup = isRecord(electron?.cleanup) ? electron.cleanup : void 0;
+  const results = Array.isArray(cleanup?.results) ? cleanup.results : [];
+  return results.flatMap((result) => cleanupSessionsForResult(result, text(details.namespace), fallbackSessionName));
+}
+function outcomeClosedSession(outcome, sessionName, fallbackSessionName) {
+  if (outcome?.status !== "closed" || outcome.succeeded !== true) {
+    return;
+  }
+  return getRestorableManagedSessionName(outcome.attemptedSessionName, fallbackSessionName) ?? getRestorableManagedSessionName(outcome.currentSessionName, fallbackSessionName) ?? getRestorableManagedSessionName(sessionName, fallbackSessionName);
+}
+function selectManagedReplaySession(options) {
+  if (options.closedSessionName !== void 0) {
+    return options.closedSessionName;
+  }
+  const { explicitSessionName, restorableDetailSessionName } = options;
+  if ((explicitSessionName ?? "").length > 0) {
+    return options.closesSession && restorableDetailSessionName === explicitSessionName ? restorableDetailSessionName : void 0;
+  }
+  if (options.usedImplicitSession || options.freshSession) {
+    return (restorableDetailSessionName ?? "").length > 0 ? restorableDetailSessionName : void 0;
+  }
+  return;
+}
+function replaySucceeded(options) {
+  const { outcome } = options;
+  const activeCurrent = outcome?.activeAfter === true && outcome.currentSessionName === options.managedSessionName && ["created", "replaced", "unchanged"].includes(text(outcome.status) ?? "");
+  if (activeCurrent || options.nestedBatchRemainsActive) {
+    return true;
+  }
+  if (typeof options.messageIsError === "boolean") {
+    return !options.messageIsError;
+  }
+  return typeof options.exitCode !== "number" || options.exitCode === 0;
+}
+function decodeManagedReplayEvent(entry, fallbackSessionName) {
+  const message = getBrowserResultMessage(entry);
+  if (!message || !isRecord(message.details)) {
+    return;
+  }
+  const details = message.details;
+  const args = Array.isArray(details.args) && details.args.every((item) => typeof item === "string") ? details.args : [];
+  if (isPlainTextInspectionArgs(args)) {
+    return;
+  }
+  return decodeLifecycleEvent(details, args, message.isError, fallbackSessionName);
+}
+function closeAllApplied(details, args, messageIsError) {
+  return details.closeAllApplied === true || messageIsError !== true && isCloseAllCommand(extractUpstreamCommandTokens(args)) || batchHasSuccessfulCloseAll(details.batchSteps);
+}
+function decodeLifecycleEvent(details, args, messageIsError, fallbackSessionName) {
+  const sessionName = text(details.sessionName);
+  const namespace = canonicalizeAgentBrowserNamespace(text(details.namespace));
+  const command = text(details.command) ?? parseCommandInfo(args).command;
+  const lifecycle = getSuccessfulBatchCloseLifecycle(details.batchSteps);
+  const nestedBatchEndsClosed = lifecycle?.endsClosed === true;
+  const nestedBatchRemainsActive = lifecycle?.endsClosed === false;
+  const closesSession = isCloseCommand(command) || nestedBatchEndsClosed;
+  const outcome = isRecord(details.managedSessionOutcome) ? details.managedSessionOutcome : void 0;
+  const closedSessionName = outcomeClosedSession(outcome, sessionName, fallbackSessionName);
+  const outcomeClosed = (closedSessionName ?? "").length > 0;
+  const restorableDetailSessionName = getRestorableManagedSessionName(sessionName, fallbackSessionName);
+  const managedSessionName = selectManagedReplaySession({
+    closedSessionName,
+    explicitSessionName: extractExplicitSessionName(args),
+    restorableDetailSessionName,
+    usedImplicitSession: details.usedImplicitSession === true,
+    freshSession: details.sessionMode === "fresh",
+    closesSession
+  });
+  const succeeded = replaySucceeded({
+    outcome,
+    managedSessionName,
+    nestedBatchRemainsActive,
+    messageIsError,
+    exitCode: details.exitCode
+  });
+  return {
+    cleanupSessions: getElectronCleanupClosedManagedSessions(details, fallbackSessionName),
+    namespace,
+    detailSessionName: sessionName,
+    restoreDisabled: details.managedSessionRestoreDisabled === true,
+    restorableDetailSessionName,
+    closeAllApplied: closeAllApplied(details, args, messageIsError),
+    nestedBatchRemainsActive,
+    managedSessionName,
+    closesSession: closesSession || outcomeClosed,
+    closeSucceeded: nestedBatchEndsClosed || outcomeClosed || succeeded,
+    command,
+    succeeded
+  };
+}
+
+// dist/extensions/agent-browser/lib/runtime-session-replay.js
+var ManagedSessionReplay = class {
+  #fallbackSessionName;
+  #freshSessionRanks = /* @__PURE__ */ new Map();
+  #restoreDisabledIdentities = /* @__PURE__ */ new Map();
+  #state;
+  #activeRestoreRank = 0;
+  #closedSessionName;
+  #freshSessionOrdinal = 0;
+  constructor(fallbackSessionName) {
+    this.#fallbackSessionName = fallbackSessionName;
+    this.#state = { active: false, sessionName: fallbackSessionName };
+  }
+  #rank(sessionName) {
+    if (sessionName === this.#fallbackSessionName) {
+      return 0;
+    }
+    if (!isRestorableManagedSessionName(sessionName, this.#fallbackSessionName)) {
+      return;
+    }
+    const existing = this.#freshSessionRanks.get(sessionName);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const nextRank = this.#freshSessionRanks.size + 1;
+    this.#freshSessionRanks.set(sessionName, nextRank);
+    return nextRank;
+  }
+  #close(identity) {
+    const namespace = canonicalizeAgentBrowserNamespace(identity.namespace);
+    if (this.#rank(identity.sessionName) === void 0 || identity.sessionName !== this.#state.sessionName || namespace !== this.#state.namespace) {
+      return;
+    }
+    this.#state = { active: false, sessionName: this.#state.sessionName };
+    this.#closedSessionName = identity.sessionName;
+  }
+  #closeAll(event) {
+    if (!event.closeAllApplied || !this.#state.active) {
+      return;
+    }
+    const restoredKey = getAgentBrowserSessionIdentityKey(this.#state.sessionName, this.#state.namespace);
+    const sessionName = event.restorableDetailSessionName;
+    const resultKey = sessionName !== void 0 && sessionName.length > 0 ? getAgentBrowserSessionIdentityKey(sessionName, event.namespace) : void 0;
+    const retainsCurrent = event.nestedBatchRemainsActive && resultKey === restoredKey;
+    if (isAgentBrowserSessionIdentityKeyInNamespace(restoredKey, event.namespace) && !retainsCurrent) {
+      this.#close(this.#state);
+    }
+  }
+  #applyCompletion(event, identity, rank) {
+    if (event.closesSession) {
+      if (event.closeSucceeded) {
+        this.#restoreDisabledIdentities.delete(getAgentBrowserSessionIdentityKey(identity.sessionName, identity.namespace));
+        this.#close(identity);
+      }
+      return;
+    }
+    if (event.succeeded && rank < this.#activeRestoreRank) {
+      return;
+    }
+    this.#state = resolveManagedSessionState({
+      command: event.command,
+      managedSessionName: identity.sessionName,
+      managedSessionNamespace: identity.namespace,
+      priorActive: this.#state.active,
+      priorNamespace: this.#state.namespace,
+      priorSessionName: this.#state.sessionName,
+      succeeded: event.succeeded
+    });
+    if (event.succeeded && this.#state.active) {
+      this.#activeRestoreRank = rank;
+      this.#closedSessionName = void 0;
+    }
+  }
+  apply(event) {
+    for (const identity of event.cleanupSessions) {
+      this.#close(identity);
+    }
+    this.#closeAll(event);
+    if (event.restoreDisabled && event.detailSessionName !== void 0) {
+      const identity = { namespace: event.namespace, sessionName: event.detailSessionName };
+      this.#restoreDisabledIdentities.set(getAgentBrowserSessionIdentityKey(identity.sessionName, identity.namespace), identity);
+    }
+    if (event.managedSessionName === void 0 || event.managedSessionName.length === 0) {
+      return;
+    }
+    const rank = this.#rank(event.managedSessionName);
+    if (rank === void 0) {
+      return;
+    }
+    this.#freshSessionOrdinal = Math.max(this.#freshSessionOrdinal, rank);
+    this.#applyCompletion(event, { namespace: event.namespace, sessionName: event.managedSessionName }, rank);
+  }
+  result() {
+    const closedSessionName = this.#closedSessionName;
+    return {
+      ...this.#state,
+      ...closedSessionName !== void 0 && closedSessionName.length > 0 ? { closedSessionName } : {},
+      freshSessionOrdinal: this.#freshSessionOrdinal,
+      managedSessionRestoreDisabledIdentities: [...this.#restoreDisabledIdentities.values()]
+    };
+  }
+};
+function restoreManagedSessionStateFromBranch(branch, fallbackSessionName) {
+  const replay = new ManagedSessionReplay(fallbackSessionName);
+  for (const entry of branch) {
+    const event = decodeManagedReplayEvent(entry, fallbackSessionName);
+    if (event) {
+      replay.apply(event);
+    }
+  }
+  return replay.result();
+}
+
+// dist/extensions/agent-browser/lib/runtime-tab-correction.js
+function normalizeComparableUrl2(url) {
+  const normalizedUrl = url.trim();
+  if (normalizedUrl.length === 0) {
+    return;
+  }
+  try {
+    const parsedUrl = new URL(normalizedUrl);
+    parsedUrl.hash = "";
+    return parsedUrl.toString();
+  } catch {
+    return;
+  }
+}
+function normalizeTabSelectionValue(value) {
+  const normalizedValue = value?.trim();
+  return normalizedValue !== void 0 && normalizedValue.length > 0 ? normalizedValue : void 0;
+}
+function extractTabSelection(tab) {
+  const tabId = normalizeTabSelectionValue(tab.tabId);
+  if (tabId !== void 0) {
+    return { selectedTab: tabId, selectionKind: "tabId" };
+  }
+  const label = normalizeTabSelectionValue(tab.label);
+  if (label !== void 0) {
+    return { selectedTab: label, selectionKind: "label" };
+  }
+  if (typeof tab.index === "number" && Number.isInteger(tab.index) && tab.index >= 0) {
+    return { selectedTab: String(tab.index), selectionKind: "index" };
+  }
+  return;
+}
+function selectMatchingTab(tabs, targetTitle) {
+  const title = typeof targetTitle === "string" ? targetTitle.trim() : "";
+  const titledMatch = title.length === 0 ? void 0 : tabs.find((tab) => typeof tab.title === "string" && tab.title.trim() === title);
+  return {
+    selection: extractTabSelection(titledMatch ?? tabs[0]),
+    targetTitle: title.length > 0 ? title : void 0
+  };
+}
+function chooseOpenResultTabCorrection(options) {
+  const normalizedTargetUrl = typeof options.targetUrl === "string" ? normalizeComparableUrl2(options.targetUrl) : void 0;
+  if (normalizedTargetUrl === void 0) {
+    return;
+  }
+  const tabsWithIndices = options.tabs.map((tab, index) => ({
+    ...tab,
+    index: typeof tab.index === "number" ? tab.index : index,
+    label: normalizeTabSelectionValue(tab.label),
+    tabId: normalizeTabSelectionValue(tab.tabId)
+  }));
+  const activeTab = tabsWithIndices.find((tab) => tab.active === true) ?? tabsWithIndices.find((tab) => tab.index === options.activeTabIndex);
+  if (activeTab && normalizeComparableUrl2(activeTab.url ?? "") === normalizedTargetUrl) {
+    return;
+  }
+  const matchingTabs = tabsWithIndices.filter((tab) => normalizeComparableUrl2(tab.url ?? "") === normalizedTargetUrl);
+  if (matchingTabs.length === 0) {
+    return;
+  }
+  const { selection, targetTitle } = selectMatchingTab(matchingTabs, options.targetTitle);
+  return selection ? { ...selection, targetTitle, targetUrl: normalizedTargetUrl } : void 0;
+}
+
+// dist/extensions/agent-browser/lib/runtime.js
+function getStartupScopedFlags(args) {
+  return LAUNCH_SCOPED_FLAG_DEFINITIONS.map((definition) => definition.flag).filter((flag) => hasLaunchScopedFlagToken(args, flag));
+}
+function withNativeSession(args) {
+  const nativeSession = getAgentBrowserProcessEnvironment().AGENT_BROWSER_SESSION;
+  if (nativeSession !== void 0 && !isPlainTextInspectionArgs(args) && extractExplicitSessionName(args) === void 0) {
+    return ["--session", nativeSession, ...args];
+  }
+  return args;
+}
+function jsonPrefix(args) {
+  return getBooleanFlagValue(args, "--json") === void 0 ? ["--json"] : [];
+}
+function planningFailure(args) {
+  const invalidValueFlag = getInvalidValueFlagDetails(args);
+  const repeatedFlag = ["--session", "--namespace"].find((flag) => scanUpstreamGlobalFlagOccurrences(args, flag).length > 1);
+  if (!invalidValueFlag && repeatedFlag === void 0) {
+    return;
+  }
+  const validationError = invalidValueFlag ? formatInvalidValueFlagError(invalidValueFlag) : `Multiple ${repeatedFlag ?? ""} flags are not supported. Pass a single ${repeatedFlag ?? ""} value; upstream uses the last occurrence while this wrapper would otherwise mis-attribute managed-session ownership.`;
+  const plan = {
+    commandInfo: {},
+    effectiveArgs: jsonPrefix(args),
+    plainTextInspection: false,
+    startupScopedFlags: [],
+    usedImplicitSession: false,
+    validationError
+  };
+  return invalidValueFlag ? { ...plan, invalidValueFlag } : plan;
+}
+function effectiveStartupFlags(args, managedNamespace) {
+  const explicitNamespacePresent = scanUpstreamGlobalFlagOccurrences(args, "--namespace").length > 0;
+  const explicitNamespace = extractExplicitNamespace(args);
+  return getStartupScopedFlags(args).filter((flag) => !(flag === "--namespace" && explicitNamespacePresent && explicitNamespace === canonicalizeAgentBrowserNamespace(managedNamespace)));
+}
+function targetsActiveManagedSession(selection, options, needsSession) {
+  const { sessionName } = selection;
+  return options.managedSessionActive && needsSession && sessionName !== void 0 && sessionName.length > 0 && getAgentBrowserSessionIdentityKey(sessionName, selection.namespace) === getAgentBrowserSessionIdentityKey(options.managedSessionName, options.managedSessionNamespace);
+}
+function activeLaunchRecovery(args, flags, command, prior) {
+  if (flags.length === 0 || isCloseCommand(command) || prior.validationError !== void 0 && prior.validationError.length > 0) {
+    return prior;
+  }
+  const explicitSession = extractExplicitSessionName(args);
+  const explicit = explicitSession !== void 0 && explicitSession.length > 0;
+  const recoveryArgs = explicit ? stripExplicitIdentityArgs(args, "--session") : args;
+  return {
+    recoveryHint: freshSessionRecoveryHint(recoveryArgs, launchFlagsRecoveryReason()),
+    validationError: [
+      `The current extension-managed agent-browser session is already running, so launch-scoped flags ${flags.join(", ")} would replace or be ignored by upstream agent-browser.`,
+      explicit ? 'Remove the explicit `--session` and retry with `sessionMode: "fresh"` to force a fresh upstream launch.' : 'Retry this call with `sessionMode: "fresh"` to force a fresh upstream launch.'
+    ].join(" ")
+  };
+}
+function activeCompatibilityPlan(args, requested, existing, prior) {
+  if (!canUseHeadlessCompatibilityUserAgent(args)) {
+    return { ...prior, compatibilityWorkaround: requested };
+  }
+  if (requested && !existing && (prior.validationError === void 0 || prior.validationError.length === 0)) {
+    const sessionName = extractExplicitSessionName(args);
+    const explicit = sessionName !== void 0 && sessionName.length > 0;
+    const recoveryArgs = explicit ? stripExplicitIdentityArgs(args, "--session") : args;
+    return {
+      compatibilityWorkaround: void 0,
+      recoveryHint: freshSessionRecoveryHint(recoveryArgs, "The requested site compatibility user agent is launch-scoped and needs a fresh browser session."),
+      validationError: explicit ? 'The current extension-managed agent-browser session is already running without the user agent required by this site. Remove the explicit `--session` and retry with `sessionMode: "fresh"` so the compatibility user agent is applied at launch.' : 'The current extension-managed agent-browser session is already running without the user agent required by this site. Retry this call with `sessionMode: "fresh"` so the compatibility user agent is applied at launch.'
+    };
+  }
+  return { ...prior, compatibilityWorkaround: requested ?? existing };
+}
+function inspectionPlan(args, commandInfo, startupScopedFlags) {
+  const explicitNamespacePresent = scanUpstreamGlobalFlagOccurrences(args, "--namespace").length > 0;
+  return {
+    commandInfo,
+    effectiveArgs: [...args],
+    namespace: explicitNamespacePresent ? extractExplicitNamespace(args) ?? "" : void 0,
+    plainTextInspection: true,
+    startupScopedFlags,
+    usedImplicitSession: false
+  };
+}
+function buildExecutionPlan(inputArgs, options) {
+  const args = withNativeSession(inputArgs);
+  const startupScopedFlags = effectiveStartupFlags(args, options.managedSessionNamespace);
+  const descriptor = parseArgvDescriptor(args);
+  const commandInfo = descriptor.commandInfo;
+  if (isPlainTextInspectionArgs(args)) {
+    return inspectionPlan(args, commandInfo, startupScopedFlags);
+  }
+  const failure = planningFailure(args);
+  if (failure) {
+    return failure;
+  }
+  const needsSession = options.browserIndependentReadConfirmation !== true && needsManagedSession(descriptor, options.stdin);
+  const selection = selectExecutionSession(args, options, {
+    command: commandInfo.command,
+    needsManagedSession: needsSession,
+    startupScopedFlags
+  });
+  const activeTarget = targetsActiveManagedSession(selection, options, needsSession);
+  const requested = getCompatibilityWorkaround(args, commandInfo);
+  const recovery = activeTarget ? activeLaunchRecovery(args, startupScopedFlags, commandInfo.command, selection) : selection;
+  const compatibility = activeTarget ? activeCompatibilityPlan(args, requested, options.managedSessionCompatibilityWorkaround, recovery) : { ...recovery, compatibilityWorkaround: requested };
+  const effectiveArgs = [...jsonPrefix(args), ...selection.prefixArgs];
+  if (compatibility.compatibilityWorkaround && !activeTarget) {
+    effectiveArgs.push("--user-agent", getDefaultHeadlessCompatUserAgent());
+  }
+  effectiveArgs.push(...selection.argsToAppend);
+  return {
+    commandInfo,
+    compatibilityWorkaround: compatibility.compatibilityWorkaround,
+    effectiveArgs,
+    managedSessionName: selection.managedSessionName,
+    namespace: selection.namespace,
+    plainTextInspection: false,
+    recoveryHint: compatibility.recoveryHint,
+    sessionName: selection.sessionName,
+    startupScopedFlags,
+    usedImplicitSession: selection.usedImplicitSession,
+    validationError: compatibility.validationError
+  };
+}
+export {
+  buildExecutionPlan,
+  canUseHeadlessCompatibilityUserAgent,
+  chooseOpenResultTabCorrection,
+  createEphemeralSessionSeed,
+  createFreshSessionName,
+  createImplicitSessionName,
+  extractCommandTokens,
+  extractUpstreamCommandTokens,
+  findCommandStartIndex,
+  getDefaultHeadlessCompatUserAgent,
+  getImplicitSessionCloseTimeoutMs,
+  getImplicitSessionIdleTimeoutMs,
+  getStartupScopedFlags,
+  isPlainTextInspectionArgs,
+  isRestorableManagedSessionName,
+  parseArgvDescriptor,
+  parseCommandInfo,
+  parseWaitCommandTokens,
+  redactInvocationArgs,
+  redactSensitiveText,
+  redactSensitiveValue,
+  resolveManagedSessionState,
+  restoreManagedSessionStateFromBranch,
+  validateToolArgs
+};