pi-agent-browser-native 0.9.5 → 0.9.7

package/dist/packaged/lib/browser-session-conversion.js

@@ -0,0 +1,2946 @@
+// dist/extensions/agent-browser/lib/browser-session-conversion.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { constants } from "node:fs";
+import { link, lstat, mkdir, open, unlink } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+// dist/extensions/agent-browser/lib/parsing.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// dist/extensions/agent-browser/lib/browser-journal-projection.js
+var ENVELOPE_MAX_BYTES = 16 * 1024 * 1024;
+var MAX_NESTING = 1024;
+var RESERVE_PER_BYTE = 16;
+var NATIVE_RECORD_BYTES = ENVELOPE_MAX_BYTES / RESERVE_PER_BYTE;
+var NATIVE_STRUCTURE_LIMIT = 64 * 1024;
+var JOURNAL_CHUNK_BYTES = 64 * 1024;
+function matches(field, key) {
+  return field === key || field === "*" && typeof key === "number";
+}
+function selectedPath(path, fields) {
+  return fields.some((field) => field.every((key, index) => matches(key, path[index])) || path.every((key, index) => matches(field[index], key)));
+}
+var JsonProjection = class {
+  fields;
+  maxBytes;
+  stack = [];
+  root;
+  literal;
+  inKey = false;
+  keyText = "";
+  bytes = 0;
+  constructor(fields, maxBytes) {
+    this.fields = fields;
+    this.maxBytes = maxBytes;
+  }
+  result() {
+    return isRecord(this.root) ? this.root : void 0;
+  }
+  reserve(size) {
+    this.bytes += size;
+    if (this.bytes > this.maxBytes) {
+      throw new Error("Selected journal envelope exceeds its bounded read size.");
+    }
+  }
+  path() {
+    const frame = this.stack.at(-1);
+    return frame ? [...frame.path, frame.key ?? frame.index] : [];
+  }
+  excluded() {
+    const frame = this.stack.at(-1);
+    return frame !== void 0 && frame.value === void 0;
+  }
+  frame() {
+    const frame = this.stack.at(-1);
+    if (!frame) {
+      throw new Error("Journal JSON container is missing.");
+    }
+    return frame;
+  }
+  put(value) {
+    const parent = this.stack.at(-1);
+    if (!parent) {
+      this.root = value;
+      return;
+    }
+    if (parent.value && value !== void 0) {
+      if (Array.isArray(parent.value)) {
+        parent.value[parent.index] = value;
+      } else {
+        if (parent.key === void 0) {
+          throw new Error("Journal object key is missing.");
+        }
+        Object.defineProperty(parent.value, parent.key, {
+          value,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    parent.key = void 0;
+    parent.index += 1;
+  }
+  consume(token) {
+    if (token.name === "startKey") {
+      this.inKey = true;
+      this.keyText = "";
+      return;
+    }
+    if (token.name === "endKey") {
+      this.inKey = false;
+      this.frame().key = this.keyText;
+      return;
+    }
+    if (this.inKey) {
+      this.consumeKey(token);
+      return;
+    }
+    switch (token.name) {
+      case "startObject":
+      case "startArray":
+        this.startContainer(token.name);
+        break;
+      case "endObject":
+      case "endArray": {
+        const frame = this.stack.pop();
+        if (!frame) {
+          throw new Error("Journal JSON container is missing.");
+        }
+        this.put(frame.value);
+        break;
+      }
+      case "startString":
+      case "startNumber":
+        this.literal = {
+          value: "",
+          selected: !this.excluded() && selectedPath(this.path(), this.fields),
+          number: token.name === "startNumber"
+        };
+        break;
+      case "stringChunk":
+      case "numberChunk":
+        this.consumeLiteral(token.value);
+        break;
+      case "endString":
+      case "endNumber":
+        this.endLiteral();
+        break;
+      case "trueValue":
+      case "falseValue":
+      case "nullValue":
+        this.consumeConstant(token.name);
+        break;
+      case "keyValue":
+      case "numberValue":
+      case "stringValue":
+      case "whitespace":
+        break;
+    }
+  }
+  consumeKey(token) {
+    if (token.name !== "stringChunk" || this.excluded()) {
+      return;
+    }
+    const path = this.frame().path;
+    const wholeContainer = this.fields.some((field) => field.every((key, index) => matches(key, path[index])));
+    if (wholeContainer || this.keyText.length <= 1024) {
+      if (wholeContainer) {
+        this.reserve(Buffer.byteLength(token.value));
+      }
+      this.keyText += token.value;
+    }
+  }
+  startContainer(name) {
+    if (this.stack.length >= MAX_NESTING) {
+      throw new Error("Journal JSON nesting exceeds 1024 levels.");
+    }
+    const currentPath = this.excluded() ? [] : this.path();
+    const selected = !this.excluded() && selectedPath(currentPath, this.fields);
+    if (selected) {
+      this.reserve(32);
+    }
+    let value;
+    if (selected) {
+      value = name === "startObject" ? {} : [];
+    }
+    this.stack.push({ path: currentPath, index: 0, value });
+  }
+  consumeLiteral(value) {
+    if (this.literal?.selected === true) {
+      this.reserve(Buffer.byteLength(value));
+      this.literal.value += value;
+    }
+  }
+  endLiteral() {
+    const literal = this.literal;
+    let value;
+    if (literal?.selected === true) {
+      value = literal.number ? Number(literal.value) : literal.value;
+    }
+    this.put(value);
+    this.literal = void 0;
+  }
+  consumeConstant(name) {
+    const selected = !this.excluded() && selectedPath(this.path(), this.fields);
+    if (selected) {
+      this.reserve(8);
+    }
+    let value;
+    if (selected) {
+      value = name === "nullValue" ? null : name === "trueValue";
+    }
+    this.put(value);
+  }
+};
+async function projectJson(input, fields, maxBytes = ENVELOPE_MAX_BYTES) {
+  const { jsonParser } = await import("stream-json/core/parser.js");
+  const chain = await import("stream-chain/defs.js");
+  const tokenize = jsonParser({ packValues: false, streamValues: true });
+  const projection = new JsonProjection(fields, maxBytes);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const consume = (text) => {
+    const tokens = tokenize(text);
+    if (tokens !== chain.none) {
+      for (const token of chain.getManyValues(tokens)) {
+        projection.consume(token);
+      }
+    }
+  };
+  for await (const chunk of input) {
+    consume(decoder.decode(chunk, { stream: true }));
+  }
+  const tail = decoder.decode();
+  if (tail.length > 0) {
+    consume(tail);
+  }
+  consume(chain.none);
+  return projection.result();
+}
+function stringEnd(bytes, open2) {
+  for (let quote = bytes.indexOf(34, open2 + 1); quote !== -1; quote = bytes.indexOf(34, quote + 1)) {
+    let escapes = 0;
+    while (bytes[quote - 1 - escapes] === 92) {
+      escapes++;
+    }
+    if (escapes % 2 === 0) {
+      return quote;
+    }
+  }
+  return -1;
+}
+var DEPTH_STEP = new Int8Array(256);
+var STRUCTURE_STEP = new Uint8Array(256);
+for (const byte of [91, 123]) {
+  DEPTH_STEP[byte] = 1;
+  STRUCTURE_STEP[byte] = 1;
+}
+for (const byte of [93, 125]) {
+  DEPTH_STEP[byte] = -1;
+}
+for (const byte of [44, 58]) {
+  STRUCTURE_STEP[byte] = 1;
+}
+function fitsNativeParse(bytes) {
+  let depth = 0;
+  let structure = 0;
+  for (let index = 0; index < bytes.length; index++) {
+    const byte = bytes[index];
+    if (byte === 34) {
+      index = stringEnd(bytes, index);
+      if (index === -1) {
+        return false;
+      }
+      continue;
+    }
+    depth += DEPTH_STEP[byte];
+    structure += STRUCTURE_STEP[byte];
+    if (depth > MAX_NESTING || structure > NATIVE_STRUCTURE_LIMIT) {
+      return false;
+    }
+  }
+  return true;
+}
+function selectValue(value, path, fields) {
+  if (typeof value !== "object" || value === null || fields.some((field) => field.every((key, index) => matches(key, path[index])))) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const selected2 = [];
+    for (const [index, item] of value.entries()) {
+      const itemPath = [...path, index];
+      if (selectedPath(itemPath, fields)) {
+        selected2[index] = selectValue(item, itemPath, fields);
+      }
+    }
+    return selected2;
+  }
+  const selected = {};
+  for (const [key, item] of Object.entries(value)) {
+    const itemPath = [...path, key];
+    if (selectedPath(itemPath, fields)) {
+      Object.defineProperty(selected, key, {
+        value: selectValue(item, itemPath, fields),
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  return selected;
+}
+function nativeProjection(bytes, fields) {
+  if (!fitsNativeParse(bytes)) {
+    return void 0;
+  }
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const selected = selectValue(value, [], fields);
+  return isRecord(selected) ? selected : void 0;
+}
+async function* chunks(bytes) {
+  for (let start = 0; start < bytes.length; start += JOURNAL_CHUNK_BYTES) {
+    yield bytes.subarray(start, start + JOURNAL_CHUNK_BYTES);
+  }
+}
+async function projectJsonBytes(bytes, fields, maxBytes = ENVELOPE_MAX_BYTES) {
+  const native = bytes.length * RESERVE_PER_BYTE <= maxBytes ? nativeProjection(bytes, fields) : void 0;
+  return native ?? projectJson(chunks(bytes), fields, maxBytes);
+}
+
+// dist/extensions/agent-browser/lib/browser-journal-reader.js
+async function* readRange(file, range) {
+  let position = range.offset;
+  const end = range.offset + range.length;
+  while (position < end) {
+    const buffer = Buffer.allocUnsafe(Math.min(JOURNAL_CHUNK_BYTES, end - position));
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
+    if (bytesRead === 0) {
+      throw new Error("Journal changed or truncated during read.");
+    }
+    position += bytesRead;
+    yield buffer.subarray(0, bytesRead);
+  }
+}
+function hasContent(buffer, start, end) {
+  for (let index = start; index < end; index++) {
+    const byte = buffer[index];
+    if (byte !== 9 && byte !== 13 && byte !== 32) {
+      return true;
+    }
+  }
+  return false;
+}
+var JournalLineFramer = class {
+  start;
+  nonblank = false;
+  parts = [];
+  held = 0;
+  constructor(offset) {
+    this.start = offset;
+  }
+  *accept(buffer, position) {
+    let index = 0;
+    while (index < buffer.length) {
+      const newline = buffer.indexOf(10, index);
+      const end = newline === -1 ? buffer.length : newline;
+      this.nonblank ||= hasContent(buffer, index, end);
+      this.hold(buffer.subarray(index, newline === -1 ? end : end + 1));
+      if (newline === -1) {
+        return;
+      }
+      const record = this.take(position + newline + 1);
+      if (record) {
+        yield record;
+      }
+      index = newline + 1;
+    }
+  }
+  final(end, sealed) {
+    return sealed ? this.take(end) : void 0;
+  }
+  hold(part) {
+    this.held += part.length;
+    if (this.held > NATIVE_RECORD_BYTES) {
+      this.parts = void 0;
+    } else {
+      this.parts?.push(part);
+    }
+  }
+  take(next) {
+    let record;
+    if (this.nonblank) {
+      const range = { offset: this.start, length: next - this.start };
+      record = this.parts ? { ...range, bytes: Buffer.concat(this.parts) } : range;
+    }
+    this.start = next;
+    this.nonblank = false;
+    this.parts = [];
+    this.held = 0;
+    return record;
+  }
+};
+async function* journalRanges(file, end, sealed = false, offset = 0) {
+  let position = offset;
+  const framer = new JournalLineFramer(offset);
+  while (position < end) {
+    const buffer = Buffer.allocUnsafe(Math.min(JOURNAL_CHUNK_BYTES, end - position));
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
+    if (bytesRead === 0) {
+      throw new Error("Journal truncated during read.");
+    }
+    yield* framer.accept(buffer.subarray(0, bytesRead), position);
+    position += bytesRead;
+  }
+  const final = framer.final(end, sealed);
+  if (final) {
+    yield final;
+  }
+}
+var STRUCTURAL_FIELDS = [
+  ["type"],
+  ["id"],
+  ["parentId"],
+  ["timestamp"],
+  ["version"],
+  ["customType"],
+  ["data", "event", "version"],
+  ["data", "snapshot", "id"],
+  ["message", "toolName"],
+  ["message", "details", "browserEventVersion"],
+  ["message", "details", "sessionName"],
+  ["message", "details", "artifactManifest", "version"],
+  ["message", "details", "electron", "action"]
+];
+async function scanJournalMetadata(file, end, sealed = false, offset = 0) {
+  const entries = [];
+  for await (const range of journalRanges(file, end, sealed, offset)) {
+    const value = range.bytes ? await projectJsonBytes(range.bytes, STRUCTURAL_FIELDS) : await projectJson(readRange(file, range), STRUCTURAL_FIELDS);
+    if (!value) {
+      throw new Error(`Expected a journal object at byte ${range.offset}.`);
+    }
+    entries.push({ offset: range.offset, length: range.length, value });
+  }
+  return entries;
+}
+
+// dist/extensions/agent-browser/lib/process-errors.js
+function getErrorCode(error) {
+  return isRecord(error) && typeof error.code === "string" ? error.code : void 0;
+}
+
+// dist/extensions/agent-browser/lib/browser-session-conversion-stream.js
+import { createHash as createHash2 } from "node:crypto";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import tokenizeJson from "stream-json/parser.js";
+import ignoreJson from "stream-json/filters/ignore.js";
+import stringifyJson from "stream-json/stringer.js";
+import disassembleJson from "stream-json/disassembler.js";
+
+// dist/extensions/agent-browser/lib/browser-transcript-contracts.js
+var BROWSER_TRANSITION_ENTRY = "agent-browser-transition";
+var BROWSER_RESULT_TOOLS = /* @__PURE__ */ new Set([
+  "agent_browser",
+  "agent_browser_code",
+  "agent_browser_action",
+  "agent_browser_qa",
+  "agent_browser_electron",
+  "agent_browser_source",
+  "agent_browser_network_source"
+]);
+var BROWSER_STATE_FIELDS = [
+  "args",
+  "command",
+  "subcommand",
+  "sessionName",
+  "namespace",
+  "sessionMode",
+  "usedImplicitSession",
+  "managedSessionSocketDir",
+  "managedSessionDaemon",
+  "ownerSessionId",
+  "agentBrowserStarted",
+  "resultCategory",
+  "exitCode",
+  "closeAllApplied",
+  "attachedBrowserSession",
+  "readConfirmation",
+  "compatibilityWorkaround",
+  "managedSessionHeadedAutosaveDisabled",
+  "managedSessionHeadedAutosaveInterval",
+  "managedSessionOutcome",
+  "managedSessionCwd",
+  "managedSessionRestoreDisabled",
+  "nativeSucceeded"
+];
+
+// dist/extensions/agent-browser/lib/browser-legacy-projection.js
+import { randomUUID } from "node:crypto";
+
+// 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
+var WEBMCP_PAGE_MUTATION_SUBCOMMANDS = /* @__PURE__ */ new Set(["invoke", "result", "cancel"]);
+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");
+}
+function isReadOnlyDiagnosticSessionTargetCommand(command, subcommand) {
+  return hasCommandCapability(command, "readOnlyDiagnosticSessionTarget") || command === "webmcp" && subcommand === "list";
+}
+function isWindowOrDiffPageTransitionCommand(command, subcommand) {
+  return command === "window" && subcommand === "new" || command === "diff" && subcommand === "url";
+}
+function isWebMcpPageMutation(command, subcommand) {
+  return command === "webmcp" && WEBMCP_PAGE_MUTATION_SUBCOMMANDS.has(subcommand ?? "");
+}
+function isUnverifiedPageTransitionCommand(command, subcommand) {
+  return ["back", "connect", "eval", "forward", "reload"].includes(command ?? "") || command === "state" && subcommand === "load" || command === "tab" && subcommand !== void 0 && !["list", "new"].includes(subcommand) || isWindowOrDiffPageTransitionCommand(command, subcommand) || isWebMcpPageMutation(command, subcommand);
+}
+
+// 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_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",
+  "--use-system-ca",
+  "--webgpu"
+]);
+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;
+}
+
+// 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));
+}
+
+// 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/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(text, index) {
+  return index < 0 || index >= text.length || text[index] === "\n" || text[index] === "\r";
+}
+function redactPasswordAssignment(text, match, prefix, offset) {
+  const end = offset + match.length;
+  if (!isLineBoundary(text, offset - 1) || !isLineBoundary(text, 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(text) {
+  return text.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(text, 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(text) {
+  return text.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(text) {
+  return text.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(text) {
+  const boundaries = new Int32Array(text.length + 1).fill(-1);
+  let quoteAtNext = -1;
+  let quoteAfterNext = -1;
+  for (let index = text.length - 1; index >= 0; index -= 1) {
+    const char = text[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 && text[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(text) {
+  let boundaries;
+  return (startIndex) => {
+    const opener = text[startIndex];
+    if (opener !== "{" && opener !== "[") {
+      return;
+    }
+    boundaries ??= buildJsonBoundaries(text);
+    const end = boundaries[startIndex + 1];
+    return end >= 0 && text[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(text) {
+  if (text === "[REDACTED]" || !/^\s*[[{"\d\-tfn]/.test(text)) {
+    return false;
+  }
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findJsonValueEnd(text, start, findEnd) {
+  const balancedEnd = findEnd(start);
+  if (balancedEnd !== void 0) {
+    return balancedEnd + 1;
+  }
+  if (text[start] === '"') {
+    const strings = /"(?:\\.|[^"\\])*"/g;
+    strings.lastIndex = start;
+    const fieldValue = strings.exec(text);
+    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 < text.length && !/[\s,\]}]/.test(text[end])) {
+    end += 1;
+  }
+  return end;
+}
+function redactSerializedJson(text, redact) {
+  if (!isSerializedJson(text)) {
+    return;
+  }
+  let output = "";
+  let cursor = 0;
+  const findEnd = createBalancedJsonEndFinder(text);
+  const strings = /"(?:\\.|[^"\\])*"/g;
+  let match;
+  while ((match = strings.exec(text)) !== null) {
+    const end = strings.lastIndex;
+    const value = parseJsonString(match[0]);
+    const redacted = redact(value);
+    if (redacted !== value) {
+      output += text.slice(cursor, match.index) + JSON.stringify(redacted);
+      cursor = end;
+    }
+    const separator = /^\s*:\s*/.exec(text.slice(end));
+    if (separator === null || !isSensitiveFieldName(value)) {
+      continue;
+    }
+    const valueStart = end + separator[0].length;
+    const valueEnd = findJsonValueEnd(text, valueStart, findEnd);
+    if (valueEnd === void 0) {
+      strings.lastIndex = valueStart;
+      strings.exec(text);
+      continue;
+    }
+    output += text.slice(cursor, valueStart) + '"[REDACTED]"';
+    cursor = valueEnd;
+    strings.lastIndex = valueEnd;
+  }
+  return output + text.slice(cursor);
+}
+function redactEmbeddedStructuredText(text, redact) {
+  let output = "";
+  let cursor = 0;
+  const findEnd = createBalancedJsonEndFinder(text);
+  const openers = /[[{]/g;
+  let match;
+  while ((match = openers.exec(text)) !== null) {
+    const endIndex = findEnd(match.index);
+    if (endIndex === void 0) {
+      continue;
+    }
+    const candidate = text.slice(match.index, endIndex + 1);
+    const redacted = redactSerializedJson(candidate, redact) ?? candidate;
+    if (redacted !== candidate) {
+      output += text.slice(cursor, match.index) + redacted;
+      cursor = endIndex + 1;
+    }
+    openers.lastIndex = endIndex + 1;
+  }
+  return cursor === 0 ? text : output + text.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 text = hash.startsWith("#") ? hash.slice(1) : hash;
+  return text.includes("=") ? new URLSearchParams(text) : 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(text) {
+  return text.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(text) {
+  return text.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(text) {
+  const urls = text.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
+function redactSensitiveText(text) {
+  const serialized = redactSerializedJson(text, redactSensitiveText);
+  if (serialized !== void 0) {
+    return serialized;
+  }
+  const embedded = redactEmbeddedStructuredText(text, 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)
+  ]));
+}
+
+// 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");
+}
+function browserStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const rows = value;
+  return rows.filter((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
+  };
+}
+function extractStringResultField(data, fieldName) {
+  if (typeof data === "string") {
+    if (fieldName === "value") {
+      return data;
+    }
+    const text2 = data.trim();
+    return text2.length > 0 ? text2 : void 0;
+  }
+  if (!isRecord(data) || typeof data[fieldName] !== "string") {
+    return void 0;
+  }
+  if (fieldName === "value") {
+    return data[fieldName];
+  }
+  const text = data[fieldName].trim();
+  return text.length > 0 ? text : void 0;
+}
+function extractSessionTabTargetFromData(data) {
+  const directTarget = normalizeSessionTabTarget({
+    targetId: isRecord(data) && typeof data.targetId === "string" ? data.targetId : void 0,
+    title: extractStringResultField(data, "title"),
+    url: extractStringResultField(data, "url")
+  });
+  if (directTarget) {
+    return directTarget;
+  }
+  if (isRecord(data) && typeof data.origin === "string") {
+    return normalizeSessionTabTarget({ url: data.origin });
+  }
+  return void 0;
+}
+function extractBatchResultCommand(item) {
+  return browserStringArray(item.command);
+}
+function confirmedNavigationResult(command, data) {
+  if (command === "confirm" && isRecord(data) && data.confirmed === true && (data.action === "navigate" || data.action === "url") && isRecord(data.result) && data.result.success === true && !detectConfirmationRequired(data)) {
+    return data.result;
+  }
+  return void 0;
+}
+function extractSessionTabTargetFromCommandData(commandTokens, data) {
+  const [command, subcommand] = commandTokens;
+  const confirmed = confirmedNavigationResult(command, data);
+  if (confirmed) {
+    return extractSessionTabTargetFromData(confirmed.data);
+  }
+  if (command === "get" && subcommand === "url") {
+    return normalizeSessionTabTarget({
+      url: extractStringResultField(data, "url") ?? extractStringResultField(data, "result")
+    });
+  }
+  return isReadOnlyDiagnosticSessionTargetCommand(command, subcommand) ? void 0 : extractSessionTabTargetFromData(data);
+}
+var BatchTargetObservation = class {
+  target;
+  pendingTitle;
+  observe(item) {
+    if (detectConfirmationRequired(item.result)) {
+      return;
+    }
+    if (this.target?.targetId !== void 0 && this.target.targetId.length > 0) {
+      this.target = normalizeSessionTabTarget({ title: this.target.title, url: this.target.url });
+    }
+    const tokens = extractUpstreamCommandTokens(extractBatchResultCommand(item));
+    this.invalidateTransition(tokens);
+    if (item.success === false) {
+      return;
+    }
+    this.observeResult(tokens, item.result);
+  }
+  invalidateTransition(tokens) {
+    const [name, subcommand] = tokens;
+    if (isOpenNavigationCommand(name) || isUnverifiedPageTransitionCommand(name, subcommand) || name === "click" && tokens.includes("--new-tab")) {
+      this.target = void 0;
+      this.pendingTitle = void 0;
+    }
+  }
+  observeResult(tokens, result) {
+    const [name, subcommand] = tokens;
+    if (isCloseCommand(name) || isSuccessfulNativeConfirmedClose(tokens, result)) {
+      this.target = void 0;
+      this.pendingTitle = void 0;
+      return;
+    }
+    if (name === "get" && subcommand === "title") {
+      this.pendingTitle = extractStringResultField(result, "title");
+      return;
+    }
+    if (name === "get" && subcommand === "url") {
+      const target = normalizeSessionTabTarget({
+        title: this.pendingTitle,
+        url: extractStringResultField(result, "url")
+      });
+      if (target) {
+        this.target = target;
+      }
+    } else {
+      const target = extractSessionTabTargetFromCommandData(tokens.slice(0, 2), result);
+      if (target) {
+        this.target = target;
+      }
+    }
+    this.pendingTitle = void 0;
+  }
+};
+function extractSessionTabTargetFromBatchResults(data) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  const observation = new BatchTargetObservation();
+  for (const item of data) {
+    if (isRecord(item)) {
+      observation.observe(item);
+    }
+  }
+  return observation.target;
+}
+function buildNoActivePageRefSnapshotInvalidation() {
+  return {
+    reason: "no-active-page",
+    summary: "The latest snapshot for this session reported No active page. Old page-scoped refs are invalid until snapshot -i succeeds."
+  };
+}
+function isNoActivePageSnapshotFailure(command, text) {
+  return command === "snapshot" && /\bno active page\b/i.test(text ?? "");
+}
+
+// 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/results/artifact-manifest.js
+function isPendingRecordingCommand(command, subcommand, kind) {
+  return command === "record" && (subcommand === "start" || subcommand === "restart") && kind === "video";
+}
+function isPendingRecordingArtifact(artifact) {
+  return artifact.recordingState === "openRecording" || artifact.status === "pending" || artifact.status === void 0 && isPendingRecordingCommand(artifact.command, artifact.subcommand, artifact.kind);
+}
+function getSessionArtifactManifestEntryKey(entry) {
+  const pathKey = entry.storageScope === "explicit-path" && entry.absolutePath !== void 0 && entry.absolutePath.length > 0 ? `${entry.storageScope}:${entry.absolutePath}` : `${entry.storageScope}:${entry.path}`;
+  const recordingSessionKey = entry.command === "record" && entry.kind === "video" && entry.session !== void 0 && entry.session.length > 0 ? getAgentBrowserSessionIdentityKey(entry.session, entry.namespace) : void 0;
+  return recordingSessionKey !== void 0 && recordingSessionKey.length > 0 ? `${pathKey}\0${recordingSessionKey}` : pathKey;
+}
+
+// dist/extensions/agent-browser/lib/results/presentation/common.js
+function getNestedLifecycleRow(row) {
+  return isRecord(row) ? row.result ?? row.data ?? row : row;
+}
+function extractAgentBrowserLifecycle(result) {
+  if (Array.isArray(result)) {
+    let latest;
+    for (const row of result) {
+      const nested = getNestedLifecycleRow(row);
+      latest = extractAgentBrowserLifecycle(nested) ?? latest;
+    }
+    return latest;
+  }
+  if (!isRecord(result)) {
+    return void 0;
+  }
+  if (isRecord(result.lifecycle) && isRecord(result.lifecycle.effectiveLaunch)) {
+    const browserLaunched = result.lifecycle.effectiveLaunch.browserLaunched;
+    if (typeof browserLaunched === "boolean") {
+      return { effectiveLaunch: { browserLaunched } };
+    }
+  }
+  return extractAgentBrowserLifecycle(result.result ?? result.data);
+}
+
+// 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 browserStateEffects(details) {
+  const state = Object.fromEntries(BROWSER_STATE_FIELDS.filter((key) => details[key] !== void 0).map((key) => [
+    key,
+    details[key]
+  ]));
+  if (Array.isArray(details.batchSteps)) {
+    state.batchSteps = details.batchSteps.filter(isRecord).map((step) => ({
+      command: step.command,
+      success: step.success,
+      lifecycle: extractAgentBrowserLifecycle(step)
+    }));
+  }
+  if (isRecord(details.electron) && (details.electron.launch !== void 0 || details.electron.cleanup !== void 0)) {
+    state.electron = { launch: details.electron.launch, cleanup: details.electron.cleanup };
+  }
+  return state;
+}
+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 snapshotDefinition(snapshot) {
+  if (snapshot.snapshotId === void 0 || snapshot.snapshotId.length === 0) {
+    throw new Error("A snapshot capture must have an identity before publication.");
+  }
+  return {
+    id: snapshot.snapshotId,
+    refs: Object.fromEntries(snapshot.refIds.map((id) => [id, snapshot.refs?.[id] ?? {}])),
+    target: snapshot.target,
+    generation: snapshot.generation
+  };
+}
+function indexedArtifacts(manifest) {
+  return new Map((manifest?.entries ?? []).map((row) => [getSessionArtifactManifestEntryKey(row), row]));
+}
+function redactedArtifact(row) {
+  const manifest = {
+    version: 1,
+    entries: [redactSensitiveValue(row)],
+    maxEntries: 1,
+    updatedAtMs: row.createdAtMs,
+    liveCount: 0,
+    evictedCount: 0
+  };
+  if (!isSessionArtifactManifest(manifest)) {
+    throw new Error("Redacted browser artifact has no valid manifest receipt.");
+  }
+  return manifest.entries[0];
+}
+function artifactChanges(previous, next) {
+  if (previous === next) {
+    return void 0;
+  }
+  const before = indexedArtifacts(previous);
+  const after = indexedArtifacts(next);
+  const upserts = [...after].filter(([key, row]) => JSON.stringify(before.get(key)) !== JSON.stringify(row)).map(([, row]) => redactedArtifact(row));
+  const removals = [...before.keys()].filter((key) => !after.has(key));
+  return upserts.length > 0 || removals.length > 0 ? {
+    upserts,
+    removals,
+    maxEntries: (next ?? previous)?.maxEntries ?? 100,
+    updatedAtMs: next?.updatedAtMs ?? Date.now()
+  } : void 0;
+}
+function applyArtifactChanges(previous, changes) {
+  if (!changes) {
+    return previous;
+  }
+  const rows = new Map((previous?.entries ?? []).map((row) => [getSessionArtifactManifestEntryKey(row), row]));
+  for (const key of changes.removals) {
+    rows.delete(key);
+  }
+  for (const row of changes.upserts) {
+    rows.set(getSessionArtifactManifestEntryKey(row), row);
+  }
+  const entries = [...rows.values()].sort((a, b) => {
+    const age = (b.evictedAtMs ?? b.createdAtMs) - (a.evictedAtMs ?? a.createdAtMs);
+    if (age !== 0) {
+      return age;
+    }
+    const pending = Number(isPendingRecordingArtifact(b)) - Number(isPendingRecordingArtifact(a));
+    return pending !== 0 ? pending : a.path.localeCompare(b.path);
+  }).slice(0, changes.maxEntries);
+  const manifest = {
+    version: 1,
+    entries,
+    maxEntries: changes.maxEntries,
+    updatedAtMs: changes.updatedAtMs,
+    liveCount: entries.filter((row) => row.retentionState === "live").length,
+    evictedCount: entries.filter((row) => row.retentionState === "evicted").length
+  };
+  if (!isSessionArtifactManifest(manifest)) {
+    throw new Error("Invalid browser artifact changes; inspect the retained journal.");
+  }
+  return entries.length > 0 ? manifest : void 0;
+}
+
+// dist/extensions/agent-browser/lib/browser-legacy-pages.js
+import { createHash } from "node:crypto";
+function legacyTarget(value) {
+  return normalizeSessionTabTarget({
+    url: typeof value.url === "string" ? value.url : void 0,
+    title: typeof value.title === "string" ? value.title : void 0,
+    targetId: typeof value.targetId === "string" ? value.targetId : void 0
+  });
+}
+function legacySnapshot(value, id) {
+  if (!isRecord(value) || !Array.isArray(value.refIds)) {
+    return void 0;
+  }
+  const refIds = browserStringArray(value.refIds).filter((ref) => /^e\d+$/.test(ref));
+  const sourceRefs = isRecord(value.refs) ? value.refs : {};
+  return snapshotDefinition({
+    snapshotId: typeof value.snapshotId === "string" ? value.snapshotId : id,
+    refIds,
+    generation: typeof value.generation === "string" ? value.generation : void 0,
+    refs: Object.fromEntries(refIds.flatMap((refId) => {
+      const ref = sourceRefs[refId];
+      if (!isRecord(ref) || typeof ref.name !== "string" || typeof ref.role !== "string") {
+        return [];
+      }
+      return [
+        [
+          refId,
+          {
+            name: ref.name,
+            role: ref.role,
+            ...typeof ref.isEditable === "boolean" ? { isEditable: ref.isEditable } : {},
+            ...typeof ref.isContentEditable === "boolean" ? { isContentEditable: ref.isContentEditable } : {}
+          }
+        ]
+      ];
+    })),
+    target: isRecord(value.target) ? legacyTarget(value.target) : void 0
+  });
+}
+function snapshotDigest(definition) {
+  return createHash("sha256").update(JSON.stringify({
+    refs: definition.refs,
+    target: definition.target,
+    generation: definition.generation
+  })).digest("hex");
+}
+function canonicalPage(prior, canonical, page) {
+  const definition = isRecord(canonical.snapshot) ? canonical.snapshot : void 0;
+  const digest = definition !== void 0 && Boolean(definition.refs) ? snapshotDigest(definition) : prior.snapshot?.digest ?? "";
+  let snapshot;
+  if (page.refs.kind === "replace" || page.refs.kind === "reuse") {
+    snapshot = { id: page.refs.snapshotId, digest, usable: true, candidate: false };
+  } else if (prior.snapshot) {
+    snapshot = { ...prior.snapshot, usable: false, candidate: canonical.event.phase === "begin" };
+  }
+  return {
+    target: page.target,
+    unknown: page.unknown,
+    reopenPending: page.reopenPending,
+    snapshot,
+    pending: canonical.event.phase === "begin" ? {
+      operationId: canonical.event.operationId,
+      toolCallId: canonical.event.toolCallId,
+      index: canonical.event.commandIndex
+    } : void 0
+  };
+}
+function parseInvalidation2(value, fallbackSummary) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  if (value.reason !== "no-active-page" && value.reason !== "page-transition") {
+    throw new Error("Invalid legacy browser ref invalidation.");
+  }
+  if (typeof value.summary === "string") {
+    return { reason: value.reason, summary: value.summary };
+  }
+  if (fallbackSummary) {
+    return {
+      reason: value.reason,
+      summary: "The prior refs were invalidated; take a fresh snapshot."
+    };
+  }
+  throw new Error("Invalid legacy browser ref invalidation summary.");
+}
+function observedInvalidation(ctx) {
+  const value = ctx.details.refSnapshotInvalidation;
+  if (isRecord(value) && (value.reason === "no-active-page" || value.reason === "page-transition")) {
+    return parseInvalidation2(value, true);
+  }
+  let error;
+  if (typeof ctx.details.error === "string") {
+    error = ctx.details.error;
+  } else if (typeof ctx.details.summary === "string") {
+    error = ctx.details.summary;
+  }
+  return isNoActivePageSnapshotFailure(ctx.command, error) ? buildNoActivePageRefSnapshotInvalidation() : void 0;
+}
+function snapshotReusable(page, details, digest) {
+  return page.snapshot?.digest === digest && (page.snapshot.usable || page.snapshot.candidate) && (!isRecord(details.refSnapshot) || typeof details.refSnapshot.snapshotId !== "string" || details.refSnapshot.snapshotId === page.snapshot.id);
+}
+var LegacyPageConversion = class {
+  ctx;
+  page;
+  definition;
+  constructor(ctx, prior) {
+    this.ctx = ctx;
+    this.page = { ...prior };
+  }
+  knownTarget() {
+    const { details, command, subcommand } = this.ctx;
+    if (!isRecord(details.compiledNetworkSourceLookup) && !isReadOnlyDiagnosticSessionTargetCommand(command, subcommand) && isRecord(details.sessionTabTarget)) {
+      this.page.target = legacyTarget(details.sessionTabTarget) ?? this.page.target;
+    } else if (command === "batch" && !isRecord(details.compiledNetworkSourceLookup)) {
+      this.page.target = extractSessionTabTargetFromBatchResults(details.data) ?? this.page.target;
+    }
+    if (this.page.target) {
+      this.page.unknown = void 0;
+    }
+    if (typeof details.sessionTabReopenPending === "boolean") {
+      this.page.reopenPending = details.sessionTabReopenPending;
+    }
+  }
+  knownRefs() {
+    const invalidation = observedInvalidation(this.ctx);
+    const candidate = invalidation ? void 0 : legacySnapshot(this.ctx.details.refSnapshot, `snapshot-${this.ctx.nativeId}`);
+    if (candidate) {
+      const digest = snapshotDigest(candidate);
+      let refs;
+      if (snapshotReusable(this.page, this.ctx.details, digest) && this.page.snapshot) {
+        refs = { kind: "reuse", snapshotId: this.page.snapshot.id };
+      } else {
+        this.definition = candidate;
+        refs = { kind: "replace", snapshotId: candidate.id };
+      }
+      this.page.snapshot = { id: refs.snapshotId, digest, usable: true, candidate: false };
+      return refs;
+    }
+    if (invalidation) {
+      this.disableSnapshot(false);
+      return { kind: "invalidate", invalidation };
+    }
+    return this.page.snapshot?.usable === true ? { kind: "reuse", snapshotId: this.page.snapshot.id } : { kind: "invalidate" };
+  }
+  disableSnapshot(candidate) {
+    if (this.page.snapshot) {
+      this.page.snapshot = { ...this.page.snapshot, usable: false, candidate };
+    }
+  }
+  change(key) {
+    return {
+      ...this.pageChange(key),
+      ...typeof this.ctx.details.sessionConfirmActions === "string" || this.ctx.details.sessionConfirmActions === null ? { confirmActions: this.ctx.details.sessionConfirmActions } : {}
+    };
+  }
+  pageChange(key) {
+    const ctx = this.ctx;
+    if (ctx.begin) {
+      this.page.target = void 0;
+      this.page.unknown = true;
+      this.page.snapshot = ctx.prior.snapshot ? { ...ctx.prior.snapshot, usable: false, candidate: true } : void 0;
+      this.page.pending = {
+        toolCallId: ctx.toolCallId,
+        operationId: ctx.operationId,
+        index: ctx.commandIndex
+      };
+      return { key, refs: { kind: "unknown" }, unknown: true };
+    }
+    if (ctx.details.sessionTabTargetUnknown === true) {
+      this.page.target = void 0;
+      this.page.unknown = true;
+      this.page.pending = void 0;
+      this.disableSnapshot(false);
+      return {
+        key,
+        refs: {
+          kind: "unknown",
+          invalidation: parseInvalidation2(ctx.details.refSnapshotInvalidation, false)
+        },
+        unknown: true
+      };
+    }
+    this.knownTarget();
+    const refs = this.knownRefs();
+    this.page.pending = void 0;
+    return {
+      key,
+      target: this.page.target,
+      unknown: this.page.unknown,
+      reopenPending: this.page.reopenPending,
+      refs
+    };
+  }
+};
+
+// dist/extensions/agent-browser/lib/browser-conversion-branches.js
+var BrowserConversionBranches = class {
+  states = /* @__PURE__ */ new Map();
+  children = /* @__PURE__ */ new Map();
+  constructor(parentIds) {
+    for (const id of parentIds) {
+      if (typeof id === "string") {
+        this.children.set(id, (this.children.get(id) ?? 0) + 1);
+      }
+    }
+  }
+  get(id) {
+    return this.states.get(id);
+  }
+  advance(id, parentId, projection) {
+    if (typeof parentId === "string") {
+      const remaining = (this.children.get(parentId) ?? 0) - 1;
+      if (remaining > 0) {
+        this.children.set(parentId, remaining);
+      } else {
+        this.children.delete(parentId);
+        this.states.delete(parentId);
+      }
+    }
+    if (this.children.has(id)) {
+      this.states.set(id, projection);
+    }
+  }
+};
+
+// dist/extensions/agent-browser/lib/browser-legacy-projection.js
+var emptyProjection = () => ({ pages: /* @__PURE__ */ new Map(), nextIndex: 0 });
+function legacyMessage(entry) {
+  if (entry.type === "custom" && entry.customType === BROWSER_TRANSITION_ENTRY && isRecord(entry.data) && isRecord(entry.data.details)) {
+    return entry.data;
+  }
+  const message = entry.type === "message" && isRecord(entry.message) ? entry.message : void 0;
+  return isLegacyToolMessage(message) ? message : void 0;
+}
+function isLegacyToolMessage(message) {
+  return message !== void 0 && typeof message.toolName === "string" && BROWSER_RESULT_TOOLS.has(message.toolName) && isRecord(message.details) && message.details.browserEventVersion !== 1;
+}
+function applyCanonical(current, parent, canonical) {
+  current.manifest = applyArtifactChanges(parent.manifest, canonical.event.artifacts);
+  for (const page of canonical.event.pages ?? []) {
+    if (page.clear === true) {
+      current.pages.delete(page.key);
+      continue;
+    }
+    current.pages.set(page.key, canonicalPage(current.pages.get(page.key) ?? {}, canonical, page));
+  }
+}
+function scriptRecord(entry, nativeId, ownerSessionId) {
+  if (entry.type !== "custom" || entry.customType !== "agent-browser-script-session" || !isRecord(entry.data)) {
+    return void 0;
+  }
+  return {
+    event: {
+      version: 1,
+      phase: "state",
+      operationId: `legacy-${nativeId}`,
+      toolCallId: `legacy-${nativeId}`,
+      commandIndex: 0,
+      isError: entry.data.cleanup !== "closed",
+      state: {
+        scriptLease: { ...entry.data, ownerSessionId: entry.data.ownerSessionId ?? ownerSessionId }
+      }
+    }
+  };
+}
+function isLegacyBegin(entry, details) {
+  return entry.type === "custom" && details.sessionTabTargetUnknown === true && details.command === void 0 && details.exitCode === void 0 && details.agentBrowserStarted === void 0;
+}
+function legacyIdentity(details) {
+  const sessionName = typeof details.sessionName === "string" ? details.sessionName : void 0;
+  const namespace = typeof details.namespace === "string" ? details.namespace : void 0;
+  const key = sessionName !== void 0 && sessionName.length > 0 ? getAgentBrowserSessionIdentityKey(sessionName, namespace) : void 0;
+  const tokens = extractUpstreamCommandTokens(browserStringArray(details.args));
+  return {
+    key,
+    namespace,
+    tokens,
+    command: typeof details.command === "string" ? details.command : tokens[0],
+    subcommand: typeof details.subcommand === "string" ? details.subcommand : tokens[1]
+  };
+}
+function legacyPrior(key, current) {
+  return key === void 0 ? {} : current.pages.get(key) ?? {};
+}
+function operationIdentity(options, current) {
+  const prior = legacyPrior(options.key, current);
+  const begin = isLegacyBegin(options.entry, options.details);
+  const pending = prior.pending?.toolCallId === options.toolCallId ? prior.pending : void 0;
+  let phase = "state";
+  if (begin) {
+    phase = "begin";
+  } else if (pending) {
+    phase = "finish";
+  }
+  let commandIndex = pending?.index ?? 0;
+  if (begin) {
+    commandIndex = current.nextIndex;
+    current.nextIndex++;
+  }
+  return {
+    prior,
+    begin,
+    phase,
+    commandIndex,
+    operationId: pending?.operationId ?? `legacy-${options.nativeId}`
+  };
+}
+function normalizeLegacyBatchStep(step) {
+  return step.success === true && isSuccessfulNativeConfirmedClose(browserStringArray(step.command), step.data) ? { ...step, command: ["close"] } : step;
+}
+function normalizeLegacyDetails(details, isError) {
+  const closed = !isError && isSuccessfulNativeConfirmedClose(extractUpstreamCommandTokens(browserStringArray(details.args)), details.data);
+  const batchSteps = Array.isArray(details.batchSteps) ? details.batchSteps.filter(isRecord).map(normalizeLegacyBatchStep) : void 0;
+  return {
+    ...details,
+    ...closed ? { command: "close", subcommand: void 0 } : {},
+    ...batchSteps !== void 0 ? { batchSteps } : {}
+  };
+}
+function context(entry, message, details, current) {
+  const nativeId = typeof entry.id === "string" ? entry.id : randomUUID();
+  const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : `legacy-${nativeId}`;
+  const replayDetails = normalizeLegacyDetails(details, message.isError === true);
+  const identity = legacyIdentity(replayDetails);
+  const operation = operationIdentity({ entry, details: replayDetails, key: identity.key, toolCallId, nativeId }, current);
+  return {
+    ...identity,
+    ...operation,
+    nativeId,
+    details: replayDetails,
+    isError: message.isError === true,
+    toolCallId
+  };
+}
+function closingLifecycle(ctx) {
+  const close = getSuccessfulBatchCloseLifecycle(ctx.details.batchSteps);
+  const closeAll = ctx.details.closeAllApplied === true || !ctx.isError && isCloseAllCommand(ctx.tokens) || batchHasSuccessfulCloseAll(ctx.details.batchSteps);
+  return {
+    closeAll,
+    lifecycleReset: !ctx.isError && isCloseCommand(ctx.command) || close !== void 0,
+    endsClosed: close?.endsClosed === true
+  };
+}
+function closePages(current, ctx) {
+  const closing = closingLifecycle(ctx);
+  const pages = [];
+  if (closing.closeAll) {
+    for (const key of current.pages.keys()) {
+      if (isAgentBrowserSessionIdentityKeyInNamespace(key, ctx.namespace)) {
+        current.pages.delete(key);
+        pages.push({ key, clear: true, refs: { kind: "invalidate" } });
+      }
+    }
+  } else if (ctx.key !== void 0 && closing.lifecycleReset) {
+    current.pages.delete(ctx.key);
+    pages.push({ key: ctx.key, clear: true, refs: { kind: "invalidate" } });
+  }
+  return { ...closing, pages };
+}
+function hasPageEffects(ctx) {
+  return ctx.begin || [
+    "sessionTabTargetUnknown",
+    "sessionTabTarget",
+    "sessionTabReopenPending",
+    "sessionConfirmActions",
+    "refSnapshot",
+    "refSnapshotInvalidation"
+  ].some((field) => ctx.details[field] !== void 0) || ctx.command === "batch" && Array.isArray(ctx.details.data);
+}
+function stampElectronState(state, ownerSessionId) {
+  if (!isRecord(state.electron)) {
+    return state;
+  }
+  const stamp = (value) => isRecord(value) ? { ...value, ownerSessionId: value.ownerSessionId ?? ownerSessionId } : value;
+  const cleanup = isRecord(state.electron.cleanup) ? state.electron.cleanup : void 0;
+  return {
+    ...state,
+    electron: {
+      ...state.electron,
+      launch: stamp(state.electron.launch),
+      ...cleanup ? {
+        cleanup: {
+          ...cleanup,
+          records: Array.isArray(cleanup.records) ? cleanup.records.map(stamp) : cleanup.records,
+          results: Array.isArray(cleanup.results) ? cleanup.results.map((row) => isRecord(row) ? { ...row, record: stamp(row.record) } : row) : cleanup.results
+        }
+      } : {}
+    }
+  };
+}
+function updateManifest(current, parent, details) {
+  if (isSessionArtifactManifest(details.artifactManifest) && (!parent.manifest || details.artifactManifest.updatedAtMs >= parent.manifest.updatedAtMs)) {
+    current.manifest = details.artifactManifest;
+  }
+  const changes = artifactChanges(parent.manifest, current.manifest);
+  if (!changes) {
+    current.manifest = parent.manifest;
+  }
+  return changes;
+}
+function convertMessage(ctx, parent, current, ownerSessionId) {
+  const closing = closePages(current, ctx);
+  const pages = closing.pages;
+  let definition;
+  const suppressPage = (closing.closeAll || closing.lifecycleReset) && (isCloseCommand(ctx.command) || closing.endsClosed);
+  if (ctx.key !== void 0 && hasPageEffects(ctx) && !suppressPage) {
+    const conversion = new LegacyPageConversion(ctx, current.pages.get(ctx.key) ?? {});
+    pages.push(conversion.change(ctx.key));
+    current.pages.set(ctx.key, conversion.page);
+    definition = conversion.definition;
+  }
+  const artifacts = updateManifest(current, parent, ctx.details);
+  return {
+    event: {
+      version: 1,
+      phase: ctx.phase,
+      operationId: ctx.operationId,
+      toolCallId: ctx.toolCallId,
+      commandIndex: ctx.commandIndex,
+      isError: ctx.isError,
+      state: stampElectronState(browserStateEffects(ctx.details), ownerSessionId),
+      pages,
+      artifacts
+    },
+    ...definition ? { snapshot: definition } : {}
+  };
+}
+function hasCanonicalBrowserEvent(entry) {
+  return isRecord(entry.data) && Object.hasOwn(entry.data, "event") && (entry.type === "message" || entry.customType === BROWSER_TRANSITION_ENTRY);
+}
+function convertLegacyBrowserEntry(entry, parent = emptyProjection(), ownerSessionId) {
+  const current = {
+    pages: new Map(parent.pages),
+    manifest: parent.manifest,
+    nextIndex: parent.nextIndex
+  };
+  const canonical = getBrowserRecord(entry);
+  if (canonical) {
+    applyCanonical(current, parent, canonical);
+    return { projection: current };
+  }
+  if (hasCanonicalBrowserEvent(entry)) {
+    throw new Error("Invalid browser event; legacy replay cannot bypass canonical validation.");
+  }
+  const script = scriptRecord(entry, typeof entry.id === "string" ? entry.id : randomUUID(), ownerSessionId);
+  if (script) {
+    return { record: script, projection: current };
+  }
+  const message = legacyMessage(entry);
+  if (!message || !isRecord(message.details)) {
+    return { projection: parent };
+  }
+  return {
+    record: convertMessage(context(entry, message, message.details, current), parent, current, ownerSessionId),
+    projection: current
+  };
+}
+function archiveParent(value, branches, linear) {
+  if (typeof value.parentId === "string") {
+    return branches.get(value.parentId) ?? emptyProjection();
+  }
+  return Object.hasOwn(value, "parentId") ? emptyProjection() : linear;
+}
+function convertBrowserEntries(entries, ownerSessionId) {
+  const branches = new BrowserConversionBranches(entries.map((value) => isRecord(value) ? value.parentId : void 0));
+  let linear = emptyProjection();
+  return entries.map((value, index) => {
+    if (!isRecord(value)) {
+      return value;
+    }
+    const entry = {
+      ...value,
+      id: typeof value.id === "string" ? value.id : `archive-${index}`,
+      parentId: value.parentId ?? null
+    };
+    const converted = convertLegacyBrowserEntry(entry, archiveParent(value, branches, linear), ownerSessionId);
+    branches.advance(entry.id, value.parentId, converted.projection);
+    linear = converted.projection;
+    return converted.record ? {
+      ...entry,
+      ...entry.type === "custom" ? { customType: BROWSER_TRANSITION_ENTRY } : {},
+      data: converted.record
+    } : entry;
+  });
+}
+
+// dist/extensions/agent-browser/lib/browser-legacy-fields.js
+var DETAILS_FIELDS = [
+  ...BROWSER_STATE_FIELDS,
+  "browserEventVersion",
+  "electron",
+  "compiledNetworkSourceLookup",
+  "sessionTabTarget",
+  "sessionTabTargetUnknown",
+  "sessionTabReopenPending",
+  "sessionConfirmActions",
+  "refSnapshot",
+  "refSnapshotInvalidation",
+  "artifactManifest",
+  "error",
+  "summary"
+];
+var CONFIRMED_CLOSE_FIELDS = [
+  ["confirmed"],
+  ["action"],
+  ["result", "success"],
+  ["result", "data", "closed"]
+];
+var LEGACY_BROWSER_FIELDS = [
+  ["data", "event"],
+  ["data", "snapshot"],
+  ["data", "cleanup"],
+  ["data", "sessionName"],
+  ["data", "ownerSessionId"],
+  ["data", "closeCommandArgs"],
+  ["data", "launchAttempted"],
+  ["data", "toolCallId"],
+  ["data", "isError"],
+  ["message", "toolName"],
+  ["message", "toolCallId"],
+  ["message", "isError"],
+  ...["data", "message"].flatMap((root) => DETAILS_FIELDS.map((field) => [root, "details", field])),
+  ...["data", "message"].flatMap((root) => CONFIRMED_CLOSE_FIELDS.flatMap((field) => [
+    [root, "details", "data", ...field],
+    [root, "details", "batchSteps", "*", "data", ...field]
+  ])),
+  ...["data", "message"].flatMap((root) => ["command", "success", "lifecycle"].map((field) => [root, "details", "batchSteps", "*", field]).concat([
+    ["data", "lifecycle"],
+    ["result", "lifecycle"]
+  ].map((field) => [root, "details", "batchSteps", "*"].concat(field)))),
+  ...["data", "message"].flatMap((root) => ["command", "success", "error"].map((field) => [root, "details", "data", "*", field]).concat(["url", "title", "origin", "targetId"].map((field) => [
+    root,
+    "details",
+    "data",
+    "*",
+    "result",
+    field
+  ])))
+];
+
+// dist/extensions/agent-browser/lib/browser-session-conversion-stream.js
+async function sourceChecksum(file, size) {
+  const hash = createHash2("sha256");
+  for await (const chunk of readRange(file, { offset: 0, length: size })) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+async function writeBytes(file, chunks2) {
+  for await (const chunk of chunks2) {
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    let offset = 0;
+    while (offset < buffer.length) {
+      const { bytesWritten } = await file.write(buffer, offset, buffer.length - offset);
+      if (bytesWritten === 0) {
+        throw new Error("Could not write converted journal.");
+      }
+      offset += bytesWritten;
+    }
+  }
+}
+async function* decodeRange(file, range) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  for await (const bytes of readRange(file, range)) {
+    yield decoder.decode(bytes, { stream: true });
+  }
+  const tail = decoder.decode();
+  if (tail.length > 0) {
+    yield tail;
+  }
+}
+async function rewriteMessage(file, range, destination, record) {
+  const tokenizer = tokenizeJson.asStream({ packValues: false, packKeys: true, streamKeys: false });
+  const filter = ignoreJson.asStream({
+    filter: /^(?:data|message\.details\.(?:refSnapshot|artifactManifest|browserEventVersion))$/
+  });
+  async function* inject(tokens) {
+    let depth = 0;
+    for await (const token of tokens) {
+      if (token.name === "startObject" || token.name === "startArray") {
+        depth++;
+      }
+      if (token.name === "endObject" || token.name === "endArray") {
+        depth--;
+        if (depth === 0) {
+          const key = { name: "keyValue", value: "data" };
+          yield key;
+          yield* disassembleJson({ packValues: false, packKeys: true, streamKeys: false })(record);
+        }
+      }
+      yield token;
+    }
+  }
+  const output = stringifyJson.asStream({ useKeyValues: true });
+  const processing = pipeline(Readable.from(decodeRange(file, range)), tokenizer, filter, inject, output);
+  try {
+    await Promise.all([writeBytes(destination, output), processing]);
+  } finally {
+    tokenizer.destroy();
+    filter.destroy();
+    output.destroy();
+  }
+  await destination.write("\n");
+}
+function isLegacyBrowserEntry(value) {
+  if (value.type === "custom" && typeof value.customType === "string" && [BROWSER_TRANSITION_ENTRY, "agent-browser-script-session"].includes(value.customType)) {
+    return true;
+  }
+  return isRecord(value.message) && typeof value.message.toolName === "string" && BROWSER_RESULT_TOOLS.has(value.message.toolName);
+}
+var BrowserConversionWriter = class {
+  file;
+  stage;
+  source;
+  ids = /* @__PURE__ */ new Set();
+  branches;
+  convertedRecords = 0;
+  snapshotDefinitions = 0;
+  constructor(file, stage, source, metadata) {
+    this.file = file;
+    this.stage = stage;
+    this.source = source;
+    this.branches = new BrowserConversionBranches(metadata.map((entry) => entry.value.type === "session" ? void 0 : entry.value.parentId));
+  }
+  get counts() {
+    return {
+      entryCount: this.ids.size,
+      convertedRecords: this.convertedRecords,
+      snapshotDefinitions: this.snapshotDefinitions
+    };
+  }
+  async conversion(entry) {
+    if (entry.value.type === "session") {
+      return void 0;
+    }
+    const id = entry.value.id;
+    if (typeof id !== "string" || this.ids.has(id)) {
+      throw new Error("Conversion source contains a missing or duplicate native entry ID.");
+    }
+    const parentId = entry.value.parentId;
+    if (parentId !== null && (typeof parentId !== "string" || !this.ids.has(parentId))) {
+      throw new Error("Conversion source contains a missing or forward parent.");
+    }
+    this.ids.add(id);
+    const parent = typeof parentId === "string" ? this.branches.get(parentId) ?? emptyProjection() : emptyProjection();
+    if (!isLegacyBrowserEntry(entry.value)) {
+      this.branches.advance(id, parentId, parent);
+      return void 0;
+    }
+    const details = await projectJson(readRange(this.file, entry), LEGACY_BROWSER_FIELDS, Infinity);
+    const conversion = convertLegacyBrowserEntry({ ...entry.value, ...details }, parent, this.source.sessionId);
+    this.branches.advance(id, parentId, conversion.projection);
+    return conversion.record;
+  }
+  async write(entry, sourceSize) {
+    const record = await this.conversion(entry);
+    if (!record) {
+      await writeBytes(this.stage, readRange(this.file, entry));
+      if (entry.offset + entry.length === sourceSize) {
+        await this.completeLastLine(sourceSize);
+      }
+      return;
+    }
+    const data = {
+      ...record,
+      archive: { sourceSha256: this.source.checksum, offset: entry.offset, length: entry.length }
+    };
+    if (entry.value.type === "message") {
+      await rewriteMessage(this.file, entry, this.stage, data);
+    } else {
+      await this.stage.write(`${JSON.stringify({ ...entry.value, customType: BROWSER_TRANSITION_ENTRY, data })}
+`);
+    }
+    this.convertedRecords++;
+    if (record.snapshot !== void 0) {
+      this.snapshotDefinitions++;
+    }
+  }
+  async completeLastLine(size) {
+    const lastByte = Buffer.alloc(1);
+    await this.file.read(lastByte, 0, 1, size - 1);
+    if (lastByte[0] !== 10) {
+      await this.stage.write("\n");
+    }
+  }
+};
+
+// dist/extensions/agent-browser/lib/browser-session-conversion.js
+async function validateConversionPaths(options) {
+  if (!options.confirmedStopped) {
+    throw new Error("Stop/quiesce the exact session writer first, then pass --confirm-stopped. Conversion never stops a session.");
+  }
+  const source = resolve(options.source);
+  const destination = resolve(options.destination);
+  if (source === destination) {
+    throw new Error("Conversion requires a separate destination; originals are never rewritten.");
+  }
+  const sourceStat = await lstat(source);
+  if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
+    throw new Error("Conversion source must be a regular file, not a symlink.");
+  }
+  const directory = dirname(destination);
+  await mkdir(directory, { mode: 448, recursive: true });
+  await validateDestination(directory, destination);
+  return { source, destination, directory, sourceStat };
+}
+async function validateDestination(directory, destination) {
+  const entry = await lstat(directory);
+  if (!entry.isDirectory() || entry.isSymbolicLink() || process.platform !== "win32" && (entry.uid !== process.getuid?.() || (entry.mode & 63) !== 0)) {
+    throw new Error("Conversion destination must be a private current-user directory (0700 on POSIX), without symlinks.");
+  }
+  try {
+    await lstat(destination);
+    throw new Error("Conversion destination is occupied.");
+  } catch (error) {
+    if (getErrorCode(error) !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function verifySourceUnchanged(file, source, initial, checksum) {
+  const final = await file.stat();
+  const finalPath = await lstat(source);
+  if (final.dev !== initial.dev || final.ino !== initial.ino || final.size !== initial.size || final.mtimeMs !== initial.mtimeMs || finalPath.dev !== initial.dev || finalPath.ino !== initial.ino || await sourceChecksum(file, initial.size) !== checksum) {
+    throw new Error("Conversion source changed; no destination was published.");
+  }
+}
+async function syncPublishedDirectory(directory) {
+  const parent = await open(directory, constants.O_RDONLY);
+  try {
+    await parent.sync();
+  } finally {
+    await parent.close();
+  }
+}
+async function convertBrowserSession(options) {
+  const { source, destination, directory, sourceStat } = await validateConversionPaths(options);
+  const file = await open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
+  const stagePath = `${destination}.${randomUUID2()}.tmp`;
+  let stage;
+  let published = false;
+  try {
+    const initial = await file.stat();
+    if (initial.dev !== sourceStat.dev || initial.ino !== sourceStat.ino) {
+      throw new Error("Conversion source changed before capture.");
+    }
+    const checksum = await sourceChecksum(file, initial.size);
+    const metadata = await scanJournalMetadata(file, initial.size, true);
+    const header = metadata.at(0);
+    if (header === void 0 || header.value.type !== "session" || typeof header.value.id !== "string") {
+      throw new Error("Conversion source has no native session header.");
+    }
+    stage = await open(stagePath, "wx+", 384);
+    const writer = new BrowserConversionWriter(file, stage, { sessionId: header.value.id, checksum }, metadata);
+    for (const entry of metadata) {
+      await writer.write(entry, initial.size);
+    }
+    await stage.sync();
+    const output = await stage.stat();
+    const destinationSha256 = await sourceChecksum(stage, output.size);
+    await verifySourceUnchanged(file, source, initial, checksum);
+    await stage.close();
+    stage = void 0;
+    await link(stagePath, destination);
+    published = true;
+    return {
+      version: 1,
+      source,
+      destination,
+      sessionId: header.value.id,
+      sourceSha256: checksum,
+      destinationSha256,
+      ...writer.counts,
+      sourceBytes: initial.size,
+      destinationBytes: output.size
+    };
+  } finally {
+    await stage?.close();
+    await file.close();
+    await unlink(stagePath).catch((error) => {
+      if (getErrorCode(error) !== "ENOENT") {
+        throw error;
+      }
+    });
+    if (published && process.platform !== "win32") {
+      await syncPublishedDirectory(directory);
+    }
+  }
+}
+export {
+  convertBrowserEntries,
+  convertBrowserSession,
+  convertLegacyBrowserEntry
+};