opensteer 0.9.0 → 0.9.2

package/dist/chunk-2TIVULZY.js

@@ -0,0 +1,4103 @@
+import { filePathToUri, resolveStoragePath, encodePathSegment, ensureDirectory, pathExists, readJsonFile, writeJsonFileAtomic, normalizeTimestamp, withFilesystemLock, resolveLocalViewPreferencesPath, resolveLocalViewServiceLockDir, readLocalViewServiceState, isLocalViewServiceStateLive, clearLocalViewServiceState, getLocalViewServiceStateLiveness, clearPersistedSessionRecord, writePersistedSessionRecord, isProcessRunning, readPersistedLocalBrowserSessionRecord, buildLocalViewSessionId, selectAttachBrowserCandidate, resolveChromeExecutablePath, readDevToolsActivePort, inspectCdpEndpoint, normalizeNonEmptyString, toCanonicalJsonValue, canonicalJsonString, sha256Hex, joinStoragePath, writeBufferIfMissing, writeJsonFileExclusive, isAlreadyExistsError, readBinaryFile, listJsonFiles, expandHome, createLocalViewSessionManifest, writeLocalViewSessionManifest, deleteLocalViewSessionManifest, CURRENT_PROCESS_OWNER, getProcessLiveness, processOwnersEqual, parseProcessOwner } from './chunk-BMPUL66S.js';
+import path7, { join, resolve, dirname, relative } from 'path';
+import { randomBytes, randomUUID } from 'crypto';
+import { spawn } from 'child_process';
+import { rm, mkdtemp, mkdir, cp, readdir, rename, stat, copyFile, readFile, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { connectPlaywrightChromiumBrowser, createPlaywrightBrowserCoreEngine, disconnectPlaywrightChromiumBrowser } from '@opensteer/engine-playwright';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+
+function normalizeScope(scope) {
+  if (scope === void 0) {
+    return {};
+  }
+  return {
+    ...scope.sessionRef === void 0 ? {} : { sessionRef: scope.sessionRef },
+    ...scope.pageRef === void 0 ? {} : { pageRef: scope.pageRef },
+    ...scope.frameRef === void 0 ? {} : { frameRef: scope.frameRef },
+    ...scope.documentRef === void 0 ? {} : { documentRef: scope.documentRef },
+    ...scope.documentEpoch === void 0 ? {} : { documentEpoch: scope.documentEpoch }
+  };
+}
+function normalizeProvenance(provenance) {
+  if (provenance === void 0) {
+    return void 0;
+  }
+  return {
+    ...provenance.sourceArtifactId === void 0 ? {} : {
+      sourceArtifactId: normalizeNonEmptyString(
+        "provenance.sourceArtifactId",
+        provenance.sourceArtifactId
+      )
+    },
+    ...provenance.transform === void 0 ? {} : { transform: normalizeNonEmptyString("provenance.transform", provenance.transform) }
+  };
+}
+async function readStructuredPayload(objectPath) {
+  return JSON.parse(Buffer.from(await readBinaryFile(objectPath)).toString("utf8"));
+}
+var FilesystemArtifactStore = class {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+    this.manifestsDirectory = path7.join(this.rootPath, "artifacts", "manifests");
+    this.objectsDirectory = path7.join(this.rootPath, "artifacts", "objects", "sha256");
+  }
+  manifestsDirectory;
+  objectsDirectory;
+  async initialize() {
+    await ensureDirectory(this.manifestsDirectory);
+    await ensureDirectory(this.objectsDirectory);
+  }
+  async writeStructured(input) {
+    const artifactId = normalizeNonEmptyString(
+      "artifactId",
+      input.artifactId ?? `artifact:${randomUUID()}`
+    );
+    const manifestPath = this.manifestPath(artifactId);
+    const jsonData = toCanonicalJsonValue(input.data);
+    const objectBytes = Buffer.from(canonicalJsonString(jsonData), "utf8");
+    const sha256 = sha256Hex(objectBytes);
+    const objectRelativePath = joinStoragePath("artifacts", "objects", "sha256", sha256);
+    const objectPath = resolveStoragePath(this.rootPath, objectRelativePath);
+    await writeBufferIfMissing(objectPath, objectBytes);
+    const provenance = normalizeProvenance(input.provenance);
+    const manifest = {
+      artifactId,
+      kind: input.kind,
+      createdAt: normalizeTimestamp("createdAt", input.createdAt ?? Date.now()),
+      ...provenance === void 0 ? {} : { provenance },
+      scope: normalizeScope(input.scope),
+      mediaType: input.mediaType ?? "application/json",
+      payloadType: "structured",
+      byteLength: objectBytes.byteLength,
+      sha256,
+      objectRelativePath
+    };
+    try {
+      await writeJsonFileExclusive(manifestPath, manifest);
+    } catch (error) {
+      if (isAlreadyExistsError(error)) {
+        throw new Error(`artifact ${artifactId} already exists`);
+      }
+      throw error;
+    }
+    return manifest;
+  }
+  async writeBinary(input) {
+    const artifactId = normalizeNonEmptyString(
+      "artifactId",
+      input.artifactId ?? `artifact:${randomUUID()}`
+    );
+    const manifestPath = this.manifestPath(artifactId);
+    const mediaType = normalizeNonEmptyString("mediaType", input.mediaType);
+    const data = new Uint8Array(input.data);
+    const sha256 = sha256Hex(data);
+    const extension = mediaTypeExtension(mediaType);
+    const objectRelativePath = joinStoragePath(
+      "artifacts",
+      "objects",
+      "sha256",
+      `${sha256}${extension}`
+    );
+    const objectPath = resolveStoragePath(this.rootPath, objectRelativePath);
+    await writeBufferIfMissing(objectPath, data);
+    const provenance = normalizeProvenance(input.provenance);
+    const manifest = {
+      artifactId,
+      kind: input.kind,
+      createdAt: normalizeTimestamp("createdAt", input.createdAt ?? Date.now()),
+      ...provenance === void 0 ? {} : { provenance },
+      scope: normalizeScope(input.scope),
+      mediaType,
+      payloadType: "binary",
+      byteLength: data.byteLength,
+      sha256,
+      objectRelativePath
+    };
+    try {
+      await writeJsonFileExclusive(manifestPath, manifest);
+    } catch (error) {
+      if (isAlreadyExistsError(error)) {
+        throw new Error(`artifact ${artifactId} already exists`);
+      }
+      throw error;
+    }
+    return manifest;
+  }
+  async getManifest(artifactId) {
+    const manifestPath = this.manifestPath(artifactId);
+    if (!await pathExists(manifestPath)) {
+      return void 0;
+    }
+    return readJsonFile(manifestPath);
+  }
+  async read(artifactId) {
+    const manifest = await this.getManifest(artifactId);
+    if (manifest === void 0) {
+      return void 0;
+    }
+    const objectPath = resolveStoragePath(this.rootPath, manifest.objectRelativePath);
+    if (manifest.kind === "screenshot") {
+      if (manifest.payloadType !== "binary") {
+        throw new Error(`artifact ${artifactId} has an invalid screenshot payload type`);
+      }
+      return {
+        manifest,
+        payload: {
+          kind: "screenshot",
+          payloadType: "binary",
+          data: await readBinaryFile(objectPath)
+        }
+      };
+    }
+    if (manifest.payloadType !== "structured") {
+      throw new Error(`artifact ${artifactId} has an invalid structured payload type`);
+    }
+    switch (manifest.kind) {
+      case "html-snapshot":
+        return {
+          manifest,
+          payload: {
+            kind: "html-snapshot",
+            payloadType: "structured",
+            data: await readStructuredPayload(objectPath)
+          }
+        };
+      case "dom-snapshot":
+        return {
+          manifest,
+          payload: {
+            kind: "dom-snapshot",
+            payloadType: "structured",
+            data: await readStructuredPayload(objectPath)
+          }
+        };
+      case "cookies":
+        return {
+          manifest,
+          payload: {
+            kind: "cookies",
+            payloadType: "structured",
+            data: await readStructuredPayload(objectPath)
+          }
+        };
+      case "storage-snapshot":
+        return {
+          manifest,
+          payload: {
+            kind: "storage-snapshot",
+            payloadType: "structured",
+            data: await readStructuredPayload(objectPath)
+          }
+        };
+      case "script-source":
+        return {
+          manifest,
+          payload: {
+            kind: "script-source",
+            payloadType: "structured",
+            data: await readStructuredPayload(objectPath)
+          }
+        };
+    }
+  }
+  async toProtocolArtifactReference(artifactId, relation) {
+    const manifest = await this.getManifest(artifactId);
+    if (manifest === void 0) {
+      return void 0;
+    }
+    return {
+      artifactId: manifest.artifactId,
+      kind: manifest.kind,
+      relation
+    };
+  }
+  async toProtocolArtifact(artifactId, options = {}) {
+    const record = await this.read(artifactId);
+    if (record === void 0) {
+      return void 0;
+    }
+    const delivery = options.delivery ?? "external";
+    const externalPayload = manifestToExternalBinaryLocation(this.rootPath, record.manifest);
+    const artifactBase = {
+      artifactId: record.manifest.artifactId,
+      createdAt: record.manifest.createdAt,
+      ...record.manifest.provenance === void 0 ? {} : { provenance: record.manifest.provenance },
+      ...record.manifest.scope.sessionRef === void 0 ? {} : { sessionRef: record.manifest.scope.sessionRef },
+      ...record.manifest.scope.pageRef === void 0 ? {} : { pageRef: record.manifest.scope.pageRef },
+      ...record.manifest.scope.frameRef === void 0 ? {} : { frameRef: record.manifest.scope.frameRef },
+      ...record.manifest.scope.documentRef === void 0 ? {} : { documentRef: record.manifest.scope.documentRef },
+      ...record.manifest.scope.documentEpoch === void 0 ? {} : { documentEpoch: record.manifest.scope.documentEpoch }
+    };
+    switch (record.payload.kind) {
+      case "screenshot":
+        return { ...artifactBase, kind: "screenshot", payload: externalPayload };
+      case "html-snapshot":
+        return {
+          ...artifactBase,
+          kind: "html-snapshot",
+          payload: delivery === "inline-if-structured" ? { delivery: "inline", data: record.payload.data } : externalPayload
+        };
+      case "dom-snapshot":
+        return {
+          ...artifactBase,
+          kind: "dom-snapshot",
+          payload: delivery === "inline-if-structured" ? { delivery: "inline", data: record.payload.data } : externalPayload
+        };
+      case "cookies":
+        return {
+          ...artifactBase,
+          kind: "cookies",
+          payload: delivery === "inline-if-structured" ? { delivery: "inline", data: record.payload.data } : externalPayload
+        };
+      case "storage-snapshot":
+        return {
+          ...artifactBase,
+          kind: "storage-snapshot",
+          payload: delivery === "inline-if-structured" ? { delivery: "inline", data: record.payload.data } : externalPayload
+        };
+      case "script-source":
+        return {
+          ...artifactBase,
+          kind: "script-source",
+          payload: delivery === "inline-if-structured" ? { delivery: "inline", data: record.payload.data } : externalPayload
+        };
+    }
+  }
+  manifestPath(artifactId) {
+    return path7.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
+  }
+};
+function createArtifactStore(rootPath) {
+  return new FilesystemArtifactStore(rootPath);
+}
+function manifestToExternalBinaryLocation(rootPath, manifest) {
+  return {
+    delivery: "external",
+    uri: filePathToUri(resolveStoragePath(rootPath, manifest.objectRelativePath)),
+    mimeType: manifest.mediaType,
+    byteLength: manifest.byteLength,
+    sha256: manifest.sha256
+  };
+}
+function mediaTypeExtension(mediaType) {
+  switch (mediaType) {
+    case "image/png":
+      return ".png";
+    case "image/jpeg":
+      return ".jpeg";
+    case "image/webp":
+      return ".webp";
+    default:
+      return "";
+  }
+}
+
+// ../runtime-core/src/observation-utils.ts
+var REDACTED = "[REDACTED]";
+var SENSITIVE_KEY_PATTERN = /(authorization|proxy[_-]?authorization|cookie|set-cookie|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|token|secret|password|passwd|private[_-]?key|database[_-]?url|db[_-]?url|session(?:id)?|csrf(?:token)?)/i;
+var SENSITIVE_VALUE_PATTERNS = [
+  /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+  /\bAIza[0-9A-Za-z_-]{20,}\b/g,
+  /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g,
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+  /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}\b/gi
+];
+function normalizeObservationContext(context) {
+  if (context === void 0) {
+    return void 0;
+  }
+  const normalized = {
+    ...context.sessionRef === void 0 ? {} : { sessionRef: context.sessionRef },
+    ...context.pageRef === void 0 ? {} : { pageRef: context.pageRef },
+    ...context.frameRef === void 0 ? {} : { frameRef: context.frameRef },
+    ...context.documentRef === void 0 ? {} : { documentRef: context.documentRef },
+    ...context.documentEpoch === void 0 ? {} : { documentEpoch: context.documentEpoch }
+  };
+  return Object.keys(normalized).length === 0 ? void 0 : normalized;
+}
+function createObservationRedactor(config) {
+  const state = createRedactionState(config);
+  return {
+    redactText(value) {
+      return redactString(value, state);
+    },
+    redactJson(value) {
+      return value === void 0 ? void 0 : redactUnknown(value, state, /* @__PURE__ */ new WeakSet());
+    },
+    redactError(error) {
+      if (error === void 0) {
+        return void 0;
+      }
+      return {
+        ...error.code === void 0 ? {} : { code: redactString(error.code, state) },
+        message: redactString(error.message, state),
+        ...error.retriable === void 0 ? {} : { retriable: error.retriable },
+        ...error.details === void 0 ? {} : { details: toCanonicalJsonValue(redactUnknown(error.details, state, /* @__PURE__ */ new WeakSet())) }
+      };
+    },
+    redactLabels(labels) {
+      if (labels === void 0) {
+        return void 0;
+      }
+      const next = Object.entries(labels).reduce(
+        (accumulator, [key, value]) => {
+          accumulator[key] = isSensitiveKey(key, state) ? REDACTED : redactString(value, state);
+          return accumulator;
+        },
+        {}
+      );
+      return Object.keys(next).length === 0 ? void 0 : next;
+    },
+    redactTraceContext(traceContext) {
+      if (traceContext === void 0) {
+        return void 0;
+      }
+      const next = {
+        ...traceContext.traceparent === void 0 ? {} : { traceparent: redactString(traceContext.traceparent, state) },
+        ...traceContext.baggage === void 0 ? {} : { baggage: redactString(traceContext.baggage, state) }
+      };
+      return Object.keys(next).length === 0 ? void 0 : next;
+    }
+  };
+}
+function createRedactionState(config) {
+  return {
+    sensitiveKeys: new Set(
+      (config?.redaction?.sensitiveKeys ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0)
+    ),
+    sensitiveValues: [
+      ...new Set(
+        (config?.redaction?.sensitiveValues ?? []).map((value) => value.trim()).filter((value) => value.length > 0)
+      )
+    ]
+  };
+}
+function redactUnknown(value, state, seen) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return redactString(value, state);
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (seen.has(value)) {
+    return REDACTED;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactUnknown(entry, state, seen));
+  }
+  const next = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    next[key] = isSensitiveKey(key, state) ? REDACTED : redactUnknown(nestedValue, state, seen);
+  }
+  return next;
+}
+function redactString(value, state) {
+  let next = value;
+  for (const secret of state.sensitiveValues) {
+    next = next.split(secret).join(REDACTED);
+  }
+  for (const pattern of SENSITIVE_VALUE_PATTERNS) {
+    next = next.replace(pattern, REDACTED);
+  }
+  return redactUrlString(next, state);
+}
+function redactUrlString(value, state) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return value;
+  }
+  let changed = false;
+  if (parsed.username) {
+    parsed.username = REDACTED;
+    changed = true;
+  }
+  if (parsed.password) {
+    parsed.password = REDACTED;
+    changed = true;
+  }
+  for (const [key] of parsed.searchParams) {
+    if (!isSensitiveKey(key, state)) {
+      continue;
+    }
+    parsed.searchParams.set(key, REDACTED);
+    changed = true;
+  }
+  return changed ? parsed.toString() : value;
+}
+function isSensitiveKey(key, state) {
+  return state.sensitiveKeys.has(key.trim().toLowerCase()) || SENSITIVE_KEY_PATTERN.test(key);
+}
+
+// ../runtime-core/src/observations.ts
+function normalizeObservabilityConfig(input) {
+  const profile = input?.profile ?? "diagnostic";
+  const labels = input?.labels === void 0 ? void 0 : Object.entries(input.labels).reduce((accumulator, [key, value]) => {
+    const normalizedKey = key.trim();
+    const normalizedValue = value.trim();
+    if (normalizedKey.length === 0 || normalizedValue.length === 0) {
+      return accumulator;
+    }
+    if (Object.keys(accumulator).length >= 20) {
+      return accumulator;
+    }
+    accumulator[normalizedKey] = normalizedValue;
+    return accumulator;
+  }, {});
+  const redaction = input?.redaction === void 0 ? void 0 : {
+    ...input.redaction.sensitiveKeys === void 0 ? {} : {
+      sensitiveKeys: input.redaction.sensitiveKeys.map((value) => value.trim()).filter((value) => value.length > 0)
+    },
+    ...input.redaction.sensitiveValues === void 0 ? {} : {
+      sensitiveValues: input.redaction.sensitiveValues.map((value) => value.trim()).filter((value) => value.length > 0)
+    }
+  };
+  return {
+    profile,
+    ...labels === void 0 || Object.keys(labels).length === 0 ? {} : { labels },
+    ...input?.traceContext === void 0 ? {} : {
+      traceContext: {
+        ...input.traceContext.traceparent === void 0 ? {} : { traceparent: input.traceContext.traceparent.trim() },
+        ...input.traceContext.baggage === void 0 ? {} : { baggage: input.traceContext.baggage.trim() }
+      }
+    },
+    ...redaction === void 0 ? {} : { redaction }
+  };
+}
+function eventFileName(sequence) {
+  return `${String(sequence).padStart(12, "0")}.json`;
+}
+var FilesystemSessionSink = class {
+  constructor(store, sessionId) {
+    this.store = store;
+    this.sessionId = sessionId;
+  }
+  append(input) {
+    return this.store.appendEvent(this.sessionId, input);
+  }
+  appendBatch(input) {
+    return this.store.appendEvents(this.sessionId, input);
+  }
+  writeArtifact(input) {
+    return this.store.writeArtifact(this.sessionId, input);
+  }
+  async flush() {
+  }
+  close(reason) {
+    return this.store.closeSession(this.sessionId, reason);
+  }
+};
+var FilesystemObservationStoreImpl = class {
+  constructor(rootPath, artifacts) {
+    this.rootPath = rootPath;
+    this.artifacts = artifacts;
+    this.sessionsDirectory = path7.join(this.rootPath, "observations", "sessions");
+  }
+  sessionsDirectory;
+  redactors = /* @__PURE__ */ new Map();
+  async initialize() {
+    await ensureDirectory(this.sessionsDirectory);
+  }
+  async openSession(input) {
+    const sessionId = normalizeNonEmptyString("sessionId", input.sessionId);
+    const openedAt = normalizeTimestamp("openedAt", input.openedAt ?? Date.now());
+    const config = normalizeObservabilityConfig(input.config);
+    const redactor = createObservationRedactor(config);
+    this.redactors.set(sessionId, redactor);
+    const redactedLabels = redactor.redactLabels(config.labels);
+    const redactedTraceContext = redactor.redactTraceContext(config.traceContext);
+    await withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const existing = await this.reconcileSessionManifest(sessionId);
+      if (existing === void 0) {
+        await ensureDirectory(this.sessionEventsDirectory(sessionId));
+        await ensureDirectory(this.sessionArtifactsDirectory(sessionId));
+        const session = {
+          sessionId,
+          profile: config.profile,
+          ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
+          ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
+          openedAt,
+          updatedAt: openedAt,
+          currentSequence: 0,
+          eventCount: 0,
+          artifactCount: 0
+        };
+        await writeJsonFileExclusive(this.sessionManifestPath(sessionId), session);
+        return;
+      }
+      const patched = {
+        ...existing,
+        profile: config.profile,
+        ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
+        ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
+        updatedAt: Math.max(existing.updatedAt, openedAt)
+      };
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), patched);
+    });
+    return new FilesystemSessionSink(this, sessionId);
+  }
+  async getSession(sessionId) {
+    const manifestPath = this.sessionManifestPath(sessionId);
+    if (!await pathExists(manifestPath)) {
+      return void 0;
+    }
+    return readJsonFile(manifestPath);
+  }
+  async appendEvent(sessionId, input) {
+    const [event] = await this.appendEvents(sessionId, [input]);
+    if (event === void 0) {
+      throw new Error(`failed to append observation event for session ${sessionId}`);
+    }
+    return event;
+  }
+  async appendEvents(sessionId, input) {
+    if (input.length === 0) {
+      return [];
+    }
+    return withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0) {
+        throw new Error(`observation session ${sessionId} was not found`);
+      }
+      const redactor = this.redactors.get(sessionId) ?? createObservationRedactor(void 0);
+      const events = [];
+      let sequence = session.currentSequence;
+      let updatedAt = session.updatedAt;
+      for (const raw of input) {
+        sequence += 1;
+        const createdAt = normalizeTimestamp("createdAt", raw.createdAt);
+        const context = normalizeObservationContext(raw.context);
+        const redactedData = raw.data === void 0 ? void 0 : redactor.redactJson(toCanonicalJsonValue(raw.data));
+        const redactedError = redactor.redactError(raw.error);
+        const event = {
+          eventId: normalizeNonEmptyString(
+            "eventId",
+            raw.eventId ?? `observation:${sessionId}:${String(sequence).padStart(12, "0")}`
+          ),
+          sessionId,
+          sequence,
+          kind: raw.kind,
+          phase: raw.phase,
+          createdAt,
+          correlationId: normalizeNonEmptyString("correlationId", raw.correlationId),
+          ...raw.spanId === void 0 ? {} : { spanId: normalizeNonEmptyString("spanId", raw.spanId) },
+          ...raw.parentSpanId === void 0 ? {} : { parentSpanId: normalizeNonEmptyString("parentSpanId", raw.parentSpanId) },
+          ...context === void 0 ? {} : { context },
+          ...redactedData === void 0 ? {} : { data: redactedData },
+          ...redactedError === void 0 ? {} : { error: redactedError },
+          ...raw.artifactIds === void 0 || raw.artifactIds.length === 0 ? {} : { artifactIds: [...raw.artifactIds] }
+        };
+        await writeJsonFileExclusive(
+          path7.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
+          event
+        );
+        updatedAt = Math.max(updatedAt, createdAt);
+        events.push(event);
+      }
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+        ...session,
+        currentSequence: sequence,
+        eventCount: session.eventCount + events.length,
+        updatedAt
+      });
+      return events;
+    });
+  }
+  async writeArtifact(sessionId, input) {
+    return withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0) {
+        throw new Error(`observation session ${sessionId} was not found`);
+      }
+      const redactor = this.redactors.get(sessionId) ?? createObservationRedactor(void 0);
+      const createdAt = normalizeTimestamp("createdAt", input.createdAt);
+      const context = normalizeObservationContext(input.context);
+      const redactedStorageKey = input.storageKey === void 0 ? void 0 : redactor.redactText(input.storageKey);
+      const redactedMetadata = input.metadata === void 0 ? void 0 : redactor.redactJson(toCanonicalJsonValue(input.metadata));
+      const artifact = {
+        artifactId: normalizeNonEmptyString("artifactId", input.artifactId),
+        sessionId,
+        kind: input.kind,
+        createdAt,
+        ...context === void 0 ? {} : { context },
+        ...input.mediaType === void 0 ? {} : { mediaType: input.mediaType },
+        ...input.byteLength === void 0 ? {} : { byteLength: input.byteLength },
+        ...input.sha256 === void 0 ? {} : { sha256: input.sha256 },
+        ...input.opensteerArtifactId === void 0 ? {} : { opensteerArtifactId: input.opensteerArtifactId },
+        ...redactedStorageKey === void 0 ? {} : { storageKey: redactedStorageKey },
+        ...redactedMetadata === void 0 ? {} : { metadata: redactedMetadata }
+      };
+      const artifactPath = this.sessionArtifactPath(sessionId, artifact.artifactId);
+      if (!await pathExists(artifactPath)) {
+        await writeJsonFileExclusive(artifactPath, artifact);
+        await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+          ...session,
+          artifactCount: session.artifactCount + 1,
+          updatedAt: Math.max(session.updatedAt, createdAt)
+        });
+      }
+      return artifact;
+    });
+  }
+  async listEvents(sessionId, input = {}) {
+    const directoryPath = this.sessionEventsDirectory(sessionId);
+    if (!await pathExists(directoryPath)) {
+      return [];
+    }
+    const files = await listJsonFiles(directoryPath);
+    const events = await Promise.all(
+      files.map((fileName) => readJsonFile(path7.join(directoryPath, fileName)))
+    );
+    const filtered = events.filter((event) => {
+      if (input.kind !== void 0 && event.kind !== input.kind) return false;
+      if (input.phase !== void 0 && event.phase !== input.phase) return false;
+      if (input.correlationId !== void 0 && event.correlationId !== input.correlationId) {
+        return false;
+      }
+      if (input.pageRef !== void 0 && event.context?.pageRef !== input.pageRef) return false;
+      if (input.afterSequence !== void 0 && event.sequence <= input.afterSequence) return false;
+      if (input.from !== void 0 && event.createdAt < input.from) return false;
+      if (input.to !== void 0 && event.createdAt > input.to) return false;
+      return true;
+    });
+    if (input.limit === void 0 || filtered.length <= input.limit) {
+      return filtered;
+    }
+    return filtered.slice(-input.limit);
+  }
+  async listArtifacts(sessionId, input = {}) {
+    const directoryPath = this.sessionArtifactsDirectory(sessionId);
+    if (!await pathExists(directoryPath)) {
+      return [];
+    }
+    const files = await listJsonFiles(directoryPath);
+    const artifacts = await Promise.all(
+      files.map(
+        (fileName) => readJsonFile(path7.join(directoryPath, fileName))
+      )
+    );
+    const filtered = artifacts.filter((artifact) => {
+      if (input.kind !== void 0 && artifact.kind !== input.kind) return false;
+      if (input.pageRef !== void 0 && artifact.context?.pageRef !== input.pageRef) return false;
+      return true;
+    });
+    if (input.limit === void 0 || filtered.length <= input.limit) {
+      return filtered;
+    }
+    return filtered.slice(-input.limit);
+  }
+  async getArtifact(sessionId, artifactId) {
+    const artifactPath = this.sessionArtifactPath(sessionId, artifactId);
+    if (!await pathExists(artifactPath)) {
+      return void 0;
+    }
+    return readJsonFile(artifactPath);
+  }
+  async closeSession(sessionId, _reason) {
+    await withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0 || session.closedAt !== void 0) {
+        return;
+      }
+      const now = Date.now();
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+        ...session,
+        updatedAt: Math.max(session.updatedAt, now),
+        closedAt: now
+      });
+    });
+    this.redactors.delete(sessionId);
+  }
+  async writeArtifactFromManifest(sessionId, manifest, kind, metadata) {
+    return this.writeArtifact(sessionId, {
+      artifactId: manifest.artifactId,
+      kind,
+      createdAt: manifest.createdAt,
+      context: manifest.scope,
+      mediaType: manifest.mediaType,
+      byteLength: manifest.byteLength,
+      sha256: manifest.sha256,
+      opensteerArtifactId: manifest.artifactId,
+      storageKey: manifestToExternalBinaryLocation(this.rootPath, manifest).uri,
+      ...metadata === void 0 ? {} : { metadata }
+    });
+  }
+  async ensureArtifactLinked(sessionId, manifest) {
+    const existing = await this.getArtifact(sessionId, manifest.artifactId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const kind = toObservationArtifactKind(manifest.kind);
+    return this.writeArtifactFromManifest(sessionId, manifest, kind);
+  }
+  async hydrateArtifactManifests(artifactIds) {
+    return (await Promise.all(
+      artifactIds.map(async (artifactId) => this.artifacts.getManifest(artifactId))
+    )).filter((value) => value !== void 0);
+  }
+  sessionDirectory(sessionId) {
+    return path7.join(this.sessionsDirectory, encodePathSegment(sessionId));
+  }
+  sessionManifestPath(sessionId) {
+    return path7.join(this.sessionDirectory(sessionId), "session.json");
+  }
+  sessionEventsDirectory(sessionId) {
+    return path7.join(this.sessionDirectory(sessionId), "events");
+  }
+  sessionArtifactsDirectory(sessionId) {
+    return path7.join(this.sessionDirectory(sessionId), "artifacts");
+  }
+  sessionArtifactPath(sessionId, artifactId) {
+    return path7.join(
+      this.sessionArtifactsDirectory(sessionId),
+      `${encodePathSegment(artifactId)}.json`
+    );
+  }
+  sessionLockPath(sessionId) {
+    return path7.join(this.sessionDirectory(sessionId), ".lock");
+  }
+  async reconcileSessionManifest(sessionId) {
+    const session = await this.getSession(sessionId);
+    if (session === void 0) {
+      return void 0;
+    }
+    const [hasEventDirectory, hasArtifactDirectory] = await Promise.all([
+      pathExists(this.sessionEventsDirectory(sessionId)),
+      pathExists(this.sessionArtifactsDirectory(sessionId))
+    ]);
+    const [eventFiles, artifactFiles] = await Promise.all([
+      hasEventDirectory ? listJsonFiles(this.sessionEventsDirectory(sessionId)) : Promise.resolve([]),
+      hasArtifactDirectory ? listJsonFiles(this.sessionArtifactsDirectory(sessionId)) : Promise.resolve([])
+    ]);
+    const currentSequence = eventFiles.reduce((maxSequence, fileName) => {
+      const parsed = Number.parseInt(fileName.replace(/\.json$/u, ""), 10);
+      return Number.isFinite(parsed) ? Math.max(maxSequence, parsed) : maxSequence;
+    }, 0);
+    const eventCount = eventFiles.length;
+    const artifactCount = artifactFiles.length;
+    if (session.currentSequence === currentSequence && session.eventCount === eventCount && session.artifactCount === artifactCount) {
+      return session;
+    }
+    const [events, artifacts] = await Promise.all([
+      Promise.all(
+        eventFiles.map(
+          (fileName) => readJsonFile(
+            path7.join(this.sessionEventsDirectory(sessionId), fileName)
+          )
+        )
+      ),
+      Promise.all(
+        artifactFiles.map(
+          (fileName) => readJsonFile(
+            path7.join(this.sessionArtifactsDirectory(sessionId), fileName)
+          )
+        )
+      )
+    ]);
+    const updatedAt = Math.max(
+      session.openedAt,
+      session.closedAt ?? 0,
+      ...events.map((event) => event.createdAt),
+      ...artifacts.map((artifact) => artifact.createdAt)
+    );
+    const reconciled = {
+      ...session,
+      currentSequence,
+      eventCount,
+      artifactCount,
+      updatedAt
+    };
+    await writeJsonFileAtomic(this.sessionManifestPath(sessionId), reconciled);
+    return reconciled;
+  }
+};
+function toObservationArtifactKind(kind) {
+  switch (kind) {
+    case "screenshot":
+      return "screenshot";
+    case "dom-snapshot":
+      return "dom-snapshot";
+    case "html-snapshot":
+      return "html-snapshot";
+    default:
+      return "other";
+  }
+}
+function createObservationStore(rootPath, artifacts) {
+  return new FilesystemObservationStoreImpl(rootPath, artifacts);
+}
+function normalizeTags(tags) {
+  if (tags === void 0) {
+    return [];
+  }
+  return Array.from(new Set(tags.map((tag) => normalizeNonEmptyString("tag", tag)))).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function normalizeProvenance2(provenance) {
+  if (provenance === void 0) {
+    return void 0;
+  }
+  return {
+    source: normalizeNonEmptyString("provenance.source", provenance.source),
+    ...provenance.sourceId === void 0 ? {} : { sourceId: normalizeNonEmptyString("provenance.sourceId", provenance.sourceId) },
+    ...provenance.capturedAt === void 0 ? {} : { capturedAt: normalizeTimestamp("provenance.capturedAt", provenance.capturedAt) },
+    ...provenance.notes === void 0 ? {} : { notes: normalizeNonEmptyString("provenance.notes", provenance.notes) }
+  };
+}
+function normalizeFreshness(freshness) {
+  if (freshness === void 0) {
+    return void 0;
+  }
+  return {
+    ...freshness.lastValidatedAt === void 0 ? {} : {
+      lastValidatedAt: normalizeTimestamp(
+        "freshness.lastValidatedAt",
+        freshness.lastValidatedAt
+      )
+    },
+    ...freshness.staleAt === void 0 ? {} : { staleAt: normalizeTimestamp("freshness.staleAt", freshness.staleAt) },
+    ...freshness.expiresAt === void 0 ? {} : { expiresAt: normalizeTimestamp("freshness.expiresAt", freshness.expiresAt) }
+  };
+}
+function compareByCreatedAtAndId(left, right) {
+  if (left.createdAt !== right.createdAt) {
+    return right.createdAt - left.createdAt;
+  }
+  return left.id.localeCompare(right.id);
+}
+var FilesystemRegistryStore = class {
+  constructor(rootPath, registryRelativePath) {
+    this.registryRelativePath = registryRelativePath;
+    const basePath = path7.join(rootPath, ...registryRelativePath);
+    this.recordsDirectory = path7.join(basePath, "records");
+    this.indexesDirectory = path7.join(basePath, "indexes", "by-key");
+  }
+  recordsDirectory;
+  indexesDirectory;
+  async initialize() {
+    await ensureDirectory(this.recordsDirectory);
+    await ensureDirectory(this.indexesDirectory);
+  }
+  async getById(id) {
+    const recordPath = this.recordPath(id);
+    if (!await pathExists(recordPath)) {
+      return void 0;
+    }
+    return readJsonFile(recordPath);
+  }
+  async resolve(input) {
+    const key = normalizeNonEmptyString("key", input.key);
+    if (input.version !== void 0) {
+      return this.resolveIndexedRecord(key, normalizeNonEmptyString("version", input.version));
+    }
+    const matches = (await this.readAllRecords()).filter((record) => record.key === key);
+    matches.sort(compareByCreatedAtAndId);
+    return matches[0];
+  }
+  async writeRecord(record) {
+    return withFilesystemLock(this.writeLockPath(), async () => {
+      if (await this.getById(record.id) !== void 0) {
+        throw new Error(`registry record ${record.id} already exists`);
+      }
+      const indexPath = this.indexPath(record.key, record.version);
+      if (await pathExists(indexPath)) {
+        const indexedRecord = await readJsonFile(indexPath);
+        throw new Error(
+          `registry record ${record.key}@${record.version} already exists as ${indexedRecord.id}`
+        );
+      }
+      const exactMatch = await this.findExactRecord(record.key, record.version);
+      if (exactMatch !== void 0) {
+        throw new Error(
+          `registry record ${record.key}@${record.version} already exists as ${exactMatch.id}`
+        );
+      }
+      try {
+        await writeJsonFileExclusive(this.recordPath(record.id), record);
+      } catch (error) {
+        if (isAlreadyExistsError(error)) {
+          throw new Error(`registry record ${record.id} already exists`);
+        }
+        throw error;
+      }
+      try {
+        await writeJsonFileExclusive(indexPath, {
+          id: record.id
+        });
+      } catch (error) {
+        if (isAlreadyExistsError(error)) {
+          throw new Error(`registry record ${record.key}@${record.version} already exists`);
+        }
+        throw error;
+      }
+      return record;
+    });
+  }
+  readAllRecords() {
+    return this.readRecordsFromDirectory();
+  }
+  async readRecordsFromDirectory() {
+    const files = await listJsonFiles(this.recordsDirectory);
+    const records = await Promise.all(
+      files.map((fileName) => readJsonFile(path7.join(this.recordsDirectory, fileName)))
+    );
+    records.sort(compareByCreatedAtAndId);
+    return records;
+  }
+  async findExactRecord(key, version) {
+    const records = await this.readAllRecords();
+    return records.find((record) => record.key === key && record.version === version);
+  }
+  async resolveIndexedRecord(key, version) {
+    const indexPath = this.indexPath(key, version);
+    if (!await pathExists(indexPath)) {
+      const exactMatches = (await this.readAllRecords()).filter(
+        (record2) => record2.key === key && record2.version === version
+      );
+      if (exactMatches.length <= 1) {
+        return exactMatches[0];
+      }
+      throw new Error(
+        `registry contains multiple records for ${key}@${version} without an index entry`
+      );
+    }
+    const indexedRecord = await readJsonFile(indexPath);
+    const record = await this.getById(indexedRecord.id);
+    if (record === void 0) {
+      throw new Error(
+        `registry index ${key}@${version} points to missing record ${indexedRecord.id}`
+      );
+    }
+    return record;
+  }
+  recordPath(id) {
+    return path7.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
+  }
+  indexPath(key, version) {
+    return path7.join(
+      this.indexesDirectory,
+      encodePathSegment(key),
+      `${encodePathSegment(version)}.json`
+    );
+  }
+  writeLockPath() {
+    return path7.join(path7.dirname(this.recordsDirectory), ".write.lock");
+  }
+};
+var FilesystemDescriptorRegistry = class extends FilesystemRegistryStore {
+  constructor(rootPath) {
+    super(rootPath, ["registry", "descriptors"]);
+  }
+  async write(input) {
+    const id = normalizeNonEmptyString("id", input.id ?? `descriptor:${randomUUID()}`);
+    const key = normalizeNonEmptyString("key", input.key);
+    const version = normalizeNonEmptyString("version", input.version);
+    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
+    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
+    if (updatedAt < createdAt) {
+      throw new RangeError("updatedAt must be greater than or equal to createdAt");
+    }
+    const payload = input.payload;
+    const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
+    const provenance = normalizeProvenance2(input.provenance);
+    const record = {
+      id,
+      key,
+      version,
+      createdAt,
+      updatedAt,
+      contentHash,
+      tags: normalizeTags(input.tags),
+      ...provenance === void 0 ? {} : { provenance },
+      payload
+    };
+    return this.writeRecord(record);
+  }
+  async list(input = {}) {
+    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
+    const records = await this.readAllRecords();
+    return key === void 0 ? records : records.filter((record) => record.key === key);
+  }
+};
+var FilesystemRequestPlanRegistry = class extends FilesystemRegistryStore {
+  constructor(rootPath) {
+    super(rootPath, ["registry", "request-plans"]);
+  }
+  async write(input) {
+    const id = normalizeNonEmptyString("id", input.id ?? `request-plan:${randomUUID()}`);
+    const key = normalizeNonEmptyString("key", input.key);
+    const version = normalizeNonEmptyString("version", input.version);
+    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
+    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
+    if (updatedAt < createdAt) {
+      throw new RangeError("updatedAt must be greater than or equal to createdAt");
+    }
+    const payload = input.payload;
+    const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
+    const provenance = normalizeProvenance2(input.provenance);
+    const freshness = normalizeFreshness(input.freshness);
+    const record = {
+      id,
+      key,
+      version,
+      createdAt,
+      updatedAt,
+      contentHash,
+      tags: normalizeTags(input.tags),
+      ...provenance === void 0 ? {} : { provenance },
+      payload,
+      ...freshness === void 0 ? {} : { freshness }
+    };
+    return this.writeRecord(record);
+  }
+  async list(input = {}) {
+    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
+    const records = await this.readAllRecords();
+    return key === void 0 ? records : records.filter((record) => record.key === key);
+  }
+  async updateFreshness(input) {
+    const id = normalizeNonEmptyString("id", input.id);
+    return withFilesystemLock(this.writeLockPath(), async () => {
+      const existing = await this.getById(id);
+      if (existing === void 0) {
+        throw new Error(`registry record ${id} was not found`);
+      }
+      const nextFreshness = normalizeFreshness(input.freshness ?? existing.freshness);
+      const nextUpdatedAt = normalizeTimestamp(
+        "updatedAt",
+        input.updatedAt ?? Math.max(Date.now(), existing.updatedAt)
+      );
+      if (nextUpdatedAt < existing.createdAt) {
+        throw new RangeError("updatedAt must be greater than or equal to createdAt");
+      }
+      const nextRecord = {
+        ...existing,
+        updatedAt: nextUpdatedAt,
+        ...nextFreshness === void 0 ? {} : { freshness: nextFreshness }
+      };
+      await writeJsonFileAtomic(this.recordPath(id), nextRecord);
+      return nextRecord;
+    });
+  }
+};
+var FilesystemInteractionTraceRegistry = class extends FilesystemRegistryStore {
+  constructor(rootPath) {
+    super(rootPath, ["registry", "interaction-traces"]);
+  }
+  async write(input) {
+    const id = normalizeNonEmptyString("id", input.id ?? `interaction-trace:${randomUUID()}`);
+    const key = normalizeNonEmptyString("key", input.key);
+    const version = normalizeNonEmptyString("version", input.version);
+    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
+    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
+    if (updatedAt < createdAt) {
+      throw new RangeError("updatedAt must be greater than or equal to createdAt");
+    }
+    const payload = input.payload;
+    const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
+    const provenance = normalizeProvenance2(input.provenance);
+    const record = {
+      id,
+      key,
+      version,
+      createdAt,
+      updatedAt,
+      contentHash,
+      tags: normalizeTags(input.tags),
+      ...provenance === void 0 ? {} : { provenance },
+      payload
+    };
+    return this.writeRecord(record);
+  }
+  async list(input = {}) {
+    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
+    const records = await this.readAllRecords();
+    return key === void 0 ? records : records.filter((record) => record.key === key);
+  }
+};
+function createDescriptorRegistry(rootPath) {
+  return new FilesystemDescriptorRegistry(rootPath);
+}
+function createRequestPlanRegistry(rootPath) {
+  return new FilesystemRequestPlanRegistry(rootPath);
+}
+function createInteractionTraceRegistry(rootPath) {
+  return new FilesystemInteractionTraceRegistry(rootPath);
+}
+var TAG_DELIMITER = "";
+var NODE_SQLITE_SPECIFIER = `node:${"sqlite"}`;
+var SAVED_NETWORK_SQLITE_SUPPORT_ERROR = "Saved-network operations require Node's built-in SQLite support. Use a Node runtime with node:sqlite enabled.";
+var SqliteSavedNetworkStore = class {
+  databasePath;
+  database;
+  directoryInitialization;
+  databaseInitialization;
+  constructor(rootPath) {
+    this.databasePath = path7.join(rootPath, "registry", "saved-network.sqlite");
+  }
+  async initialize() {
+    await this.ensureDatabaseDirectory();
+  }
+  async save(records, options) {
+    const database = await this.requireDatabase();
+    const upsertRecord = database.prepare(buildSavedNetworkUpsertSql(options.bodyWriteMode));
+    const insertTag = database.prepare(`
+      INSERT OR IGNORE INTO saved_network_tags (record_id, tag)
+      VALUES (@record_id, @tag)
+    `);
+    return withSqliteTransaction(database, () => {
+      let savedCount = 0;
+      for (const entry of records) {
+        const url = new URL(entry.record.url);
+        const pageRefKey = entry.record.pageRef ?? "";
+        upsertRecord.run({
+          record_id: entry.recordId,
+          request_id: entry.record.requestId,
+          session_ref: entry.record.sessionRef,
+          page_ref: entry.record.pageRef ?? null,
+          page_ref_key: pageRefKey,
+          frame_ref: entry.record.frameRef ?? null,
+          document_ref: entry.record.documentRef ?? null,
+          capture: entry.capture ?? null,
+          method: entry.record.method,
+          method_lc: entry.record.method.toLowerCase(),
+          url: entry.record.url,
+          url_lc: entry.record.url.toLowerCase(),
+          hostname: url.hostname,
+          hostname_lc: url.hostname.toLowerCase(),
+          path: url.pathname,
+          path_lc: url.pathname.toLowerCase(),
+          status: entry.record.status ?? null,
+          status_text: entry.record.statusText ?? null,
+          resource_type: entry.record.resourceType,
+          navigation_request: entry.record.navigationRequest ? 1 : 0,
+          request_headers_json: JSON.stringify(entry.record.requestHeaders),
+          response_headers_json: JSON.stringify(entry.record.responseHeaders),
+          request_body_json: stringifyOptional(entry.record.requestBody),
+          response_body_json: stringifyOptional(entry.record.responseBody),
+          initiator_json: stringifyOptional(entry.record.initiator),
+          timing_json: stringifyOptional(entry.record.timing),
+          transfer_json: stringifyOptional(entry.record.transfer),
+          source_json: stringifyOptional(entry.record.source),
+          capture_state: entry.record.captureState ?? "complete",
+          request_body_state: entry.record.requestBodyState ?? (entry.record.requestBody === void 0 ? "skipped" : "complete"),
+          response_body_state: entry.record.responseBodyState ?? (entry.record.responseBody === void 0 ? "skipped" : "complete"),
+          request_body_skip_reason: entry.record.requestBodySkipReason ?? null,
+          response_body_skip_reason: entry.record.responseBodySkipReason ?? null,
+          request_body_error: entry.record.requestBodyError ?? null,
+          response_body_error: entry.record.responseBodyError ?? null,
+          redirect_from_request_id: entry.record.redirectFromRequestId ?? null,
+          redirect_to_request_id: entry.record.redirectToRequestId ?? null,
+          saved_at: entry.savedAt ?? Date.now()
+        });
+        const tags = new Set(entry.tags ?? []);
+        if (options.tag !== void 0) {
+          tags.add(options.tag);
+        }
+        for (const currentTag of tags) {
+          const result = insertTag.run({
+            record_id: entry.recordId,
+            tag: currentTag
+          });
+          savedCount += result.changes ?? 0;
+        }
+      }
+      return savedCount;
+    });
+  }
+  async tagByFilter(filter, tag) {
+    const database = await this.requireDatabase();
+    const { whereSql, parameters } = buildSavedNetworkWhere(filter);
+    const selectRecords = database.prepare(
+      `
+        SELECT r.record_id
+        FROM saved_network_records r
+        ${whereSql}
+      `
+    );
+    const insertTag = database.prepare(`
+      INSERT OR IGNORE INTO saved_network_tags (record_id, tag)
+      VALUES (@record_id, @tag)
+    `);
+    return withSqliteTransaction(database, () => {
+      let taggedCount = 0;
+      const rows = selectRecords.all(
+        ...parameters
+      );
+      for (const row of rows) {
+        const recordId = row.record_id;
+        if (typeof recordId !== "string") {
+          continue;
+        }
+        const result = insertTag.run({
+          record_id: recordId,
+          tag
+        });
+        taggedCount += result.changes ?? 0;
+      }
+      return taggedCount;
+    });
+  }
+  async query(input = {}) {
+    const database = await this.requireDatabase();
+    const limit = Math.max(1, Math.min(input.limit ?? 50, 1e3));
+    const { whereSql, parameters } = buildSavedNetworkWhere(input);
+    const rows = database.prepare(
+      `
+      SELECT
+        r.*,
+        GROUP_CONCAT(t.tag, '${TAG_DELIMITER}') AS tags
+      FROM saved_network_records r
+      LEFT JOIN saved_network_tags t
+        ON t.record_id = r.record_id
+      ${whereSql}
+      GROUP BY r.record_id
+      ORDER BY r.saved_at DESC, r.record_id ASC
+      LIMIT ?
+    `
+    ).all(
+      ...parameters,
+      limit
+    );
+    return rows.map((row) => inflateSavedNetworkRow(row, input.includeBodies ?? false));
+  }
+  async getByRecordId(recordId, options = {}) {
+    const [record] = await this.query({
+      recordId,
+      ...options.includeBodies === void 0 ? {} : { includeBodies: options.includeBodies },
+      limit: 1
+    });
+    return record;
+  }
+  async clear(input = {}) {
+    const database = await this.requireDatabase();
+    const countAll = database.prepare(`SELECT COUNT(*) AS cleared FROM saved_network_records`);
+    const deleteAllRecords = database.prepare(`DELETE FROM saved_network_records`);
+    const { whereSql, parameters } = buildSavedNetworkWhere(input);
+    const countFiltered = database.prepare(`
+      SELECT COUNT(*) AS cleared
+      FROM saved_network_records r
+      ${whereSql}
+    `);
+    const deleteFiltered = database.prepare(`
+      DELETE FROM saved_network_records
+      WHERE record_id IN (
+        SELECT r.record_id
+        FROM saved_network_records r
+        ${whereSql}
+      )
+    `);
+    return withSqliteTransaction(database, () => {
+      if (input.capture === void 0 && input.tag === void 0) {
+        const cleared2 = countAll.get().cleared;
+        deleteAllRecords.run();
+        return cleared2;
+      }
+      const args = parameters;
+      const cleared = countFiltered.get(...args).cleared;
+      deleteFiltered.run(...args);
+      return cleared;
+    });
+  }
+  async *iterateBatches(options = {}) {
+    const database = await this.requireDatabase();
+    const batchSize = Math.max(1, Math.min(options.batchSize ?? 500, 1e3));
+    let cursor;
+    while (true) {
+      const rows = database.prepare(
+        `
+      SELECT
+        r.*,
+        GROUP_CONCAT(t.tag, '${TAG_DELIMITER}') AS tags
+      FROM saved_network_records r
+      LEFT JOIN saved_network_tags t
+        ON t.record_id = r.record_id
+      ${cursor === void 0 ? "" : "WHERE r.saved_at > ? OR (r.saved_at = ? AND r.record_id > ?)"}
+      GROUP BY r.record_id
+      ORDER BY r.saved_at ASC, r.record_id ASC
+      LIMIT ?
+    `
+      ).all(
+        ...cursor === void 0 ? [] : [cursor.savedAt, cursor.savedAt, cursor.recordId],
+        batchSize
+      );
+      if (rows.length === 0) {
+        return;
+      }
+      yield rows.map((row) => inflateSavedNetworkRow(row, options.includeBodies ?? true));
+      const lastRow = rows.at(-1);
+      if (lastRow === void 0) {
+        return;
+      }
+      cursor = {
+        savedAt: lastRow.saved_at,
+        recordId: lastRow.record_id
+      };
+    }
+  }
+  close() {
+    if (this.database !== void 0) {
+      closeSqliteDatabase(this.database);
+      this.database = void 0;
+      this.databaseInitialization = void 0;
+    }
+  }
+  async requireDatabase() {
+    if (this.database) {
+      return this.database;
+    }
+    this.databaseInitialization ??= this.openDatabase();
+    try {
+      return await this.databaseInitialization;
+    } catch (error) {
+      this.databaseInitialization = void 0;
+      throw error;
+    }
+  }
+  async openDatabase() {
+    await this.ensureDatabaseDirectory();
+    let DatabaseSync;
+    try {
+      ({ DatabaseSync } = await import(NODE_SQLITE_SPECIFIER));
+    } catch (error) {
+      throw normalizeSqliteImportError(error);
+    }
+    const database = new DatabaseSync(this.databasePath);
+    try {
+      this.configureDatabase(database);
+      this.database = database;
+      return database;
+    } catch (error) {
+      closeSqliteDatabase(database);
+      throw error;
+    }
+  }
+  async ensureDatabaseDirectory() {
+    this.directoryInitialization ??= ensureDirectory(path7.dirname(this.databasePath)).catch(
+      (error) => {
+        this.directoryInitialization = void 0;
+        throw error;
+      }
+    );
+    await this.directoryInitialization;
+  }
+  configureDatabase(database) {
+    database.exec("PRAGMA journal_mode = WAL");
+    database.exec("PRAGMA foreign_keys = ON");
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS saved_network_records (
+        record_id TEXT PRIMARY KEY,
+        request_id TEXT NOT NULL,
+        session_ref TEXT NOT NULL,
+        page_ref TEXT,
+        page_ref_key TEXT NOT NULL,
+        frame_ref TEXT,
+        document_ref TEXT,
+        capture TEXT,
+        method TEXT NOT NULL,
+        method_lc TEXT NOT NULL,
+        url TEXT NOT NULL,
+        url_lc TEXT NOT NULL,
+        hostname TEXT NOT NULL,
+        hostname_lc TEXT NOT NULL,
+        path TEXT NOT NULL,
+        path_lc TEXT NOT NULL,
+        status INTEGER,
+        status_text TEXT,
+        resource_type TEXT NOT NULL,
+        navigation_request INTEGER NOT NULL,
+        request_headers_json TEXT NOT NULL,
+        response_headers_json TEXT NOT NULL,
+        request_body_json TEXT,
+        response_body_json TEXT,
+        initiator_json TEXT,
+        timing_json TEXT,
+        transfer_json TEXT,
+        source_json TEXT,
+        capture_state TEXT NOT NULL,
+        request_body_state TEXT NOT NULL,
+        response_body_state TEXT NOT NULL,
+        request_body_skip_reason TEXT,
+        response_body_skip_reason TEXT,
+        request_body_error TEXT,
+        response_body_error TEXT,
+        redirect_from_request_id TEXT,
+        redirect_to_request_id TEXT,
+        saved_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS saved_network_tags (
+        record_id TEXT NOT NULL REFERENCES saved_network_records(record_id) ON DELETE CASCADE,
+        tag TEXT NOT NULL,
+        PRIMARY KEY (record_id, tag)
+      );
+
+      CREATE INDEX IF NOT EXISTS saved_network_tags_tag
+        ON saved_network_tags (tag);
+    `);
+    database.exec(`DROP INDEX IF EXISTS saved_network_records_scope_request`);
+    database.exec(`
+      CREATE INDEX IF NOT EXISTS saved_network_records_scope_request
+        ON saved_network_records (session_ref, page_ref_key, request_id)
+    `);
+    database.exec(`
+      CREATE INDEX IF NOT EXISTS saved_network_records_saved_at
+        ON saved_network_records (saved_at DESC)
+    `);
+    database.exec(`
+      CREATE INDEX IF NOT EXISTS saved_network_records_capture
+        ON saved_network_records (capture)
+    `);
+    this.ensureColumn(
+      database,
+      "saved_network_records",
+      "capture_state",
+      "TEXT NOT NULL DEFAULT 'complete'"
+    );
+    this.ensureColumn(database, "saved_network_records", "capture", "TEXT");
+    this.ensureColumn(
+      database,
+      "saved_network_records",
+      "request_body_state",
+      "TEXT NOT NULL DEFAULT 'skipped'"
+    );
+    this.ensureColumn(
+      database,
+      "saved_network_records",
+      "response_body_state",
+      "TEXT NOT NULL DEFAULT 'skipped'"
+    );
+    this.ensureColumn(database, "saved_network_records", "request_body_skip_reason", "TEXT");
+    this.ensureColumn(database, "saved_network_records", "response_body_skip_reason", "TEXT");
+    this.ensureColumn(database, "saved_network_records", "request_body_error", "TEXT");
+    this.ensureColumn(database, "saved_network_records", "response_body_error", "TEXT");
+  }
+  ensureColumn(database, table, column, definition) {
+    const rows = database.prepare(`PRAGMA table_info(${table})`).all();
+    if (rows.some((row) => row.name === column)) {
+      return;
+    }
+    database.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  }
+};
+function buildSavedNetworkWhere(input) {
+  const clauses = [];
+  const parameters = [];
+  if (input.pageRef !== void 0) {
+    clauses.push("r.page_ref_key = ?");
+    parameters.push(input.pageRef);
+  }
+  if (input.recordId !== void 0) {
+    clauses.push("r.record_id = ?");
+    parameters.push(input.recordId);
+  }
+  if (input.requestId !== void 0) {
+    clauses.push("r.request_id = ?");
+    parameters.push(input.requestId);
+  }
+  if (input.capture !== void 0) {
+    clauses.push("r.capture = ?");
+    parameters.push(input.capture);
+  }
+  if (input.tag !== void 0) {
+    clauses.push(`
+      EXISTS (
+        SELECT 1
+        FROM saved_network_tags exact_tag
+        WHERE exact_tag.record_id = r.record_id
+          AND exact_tag.tag = ?
+      )
+    `);
+    parameters.push(input.tag);
+  }
+  if (input.url !== void 0) {
+    clauses.push("instr(r.url_lc, ?) > 0");
+    parameters.push(input.url.toLowerCase());
+  }
+  if (input.hostname !== void 0) {
+    clauses.push("instr(r.hostname_lc, ?) > 0");
+    parameters.push(input.hostname.toLowerCase());
+  }
+  if (input.path !== void 0) {
+    clauses.push("instr(r.path_lc, ?) > 0");
+    parameters.push(input.path.toLowerCase());
+  }
+  if (input.method !== void 0) {
+    clauses.push("instr(r.method_lc, ?) > 0");
+    parameters.push(input.method.toLowerCase());
+  }
+  if (input.status !== void 0) {
+    clauses.push("instr(lower(COALESCE(CAST(r.status AS TEXT), '')), ?) > 0");
+    parameters.push(String(input.status).toLowerCase());
+  }
+  if (input.resourceType !== void 0) {
+    clauses.push("r.resource_type = ?");
+    parameters.push(input.resourceType);
+  }
+  return {
+    whereSql: clauses.length === 0 ? "" : `WHERE ${clauses.join(" AND ")}`,
+    parameters
+  };
+}
+function buildSavedNetworkUpsertSql(bodyWriteMode) {
+  const bodyUpdateSql = bodyWriteMode === "authoritative" ? `
+        request_body_json = excluded.request_body_json,
+        response_body_json = excluded.response_body_json,
+        request_body_state = excluded.request_body_state,
+        response_body_state = excluded.response_body_state,
+        request_body_skip_reason = excluded.request_body_skip_reason,
+        response_body_skip_reason = excluded.response_body_skip_reason,
+        request_body_error = excluded.request_body_error,
+        response_body_error = excluded.response_body_error,
+` : "";
+  return `
+      INSERT INTO saved_network_records (
+        record_id,
+        request_id,
+        session_ref,
+        page_ref,
+        page_ref_key,
+        frame_ref,
+        document_ref,
+        capture,
+        method,
+        method_lc,
+        url,
+        url_lc,
+        hostname,
+        hostname_lc,
+        path,
+        path_lc,
+        status,
+        status_text,
+        resource_type,
+        navigation_request,
+        request_headers_json,
+        response_headers_json,
+        request_body_json,
+        response_body_json,
+        initiator_json,
+        timing_json,
+        transfer_json,
+        source_json,
+        capture_state,
+        request_body_state,
+        response_body_state,
+        request_body_skip_reason,
+        response_body_skip_reason,
+        request_body_error,
+        response_body_error,
+        redirect_from_request_id,
+        redirect_to_request_id,
+        saved_at
+      ) VALUES (
+        @record_id,
+        @request_id,
+        @session_ref,
+        @page_ref,
+        @page_ref_key,
+        @frame_ref,
+        @document_ref,
+        @capture,
+        @method,
+        @method_lc,
+        @url,
+        @url_lc,
+        @hostname,
+        @hostname_lc,
+        @path,
+        @path_lc,
+        @status,
+        @status_text,
+        @resource_type,
+        @navigation_request,
+        @request_headers_json,
+        @response_headers_json,
+        @request_body_json,
+        @response_body_json,
+        @initiator_json,
+        @timing_json,
+        @transfer_json,
+        @source_json,
+        @capture_state,
+        @request_body_state,
+        @response_body_state,
+        @request_body_skip_reason,
+        @response_body_skip_reason,
+        @request_body_error,
+        @response_body_error,
+        @redirect_from_request_id,
+        @redirect_to_request_id,
+        @saved_at
+      )
+      ON CONFLICT(record_id) DO UPDATE SET
+        page_ref = excluded.page_ref,
+        page_ref_key = excluded.page_ref_key,
+        frame_ref = excluded.frame_ref,
+        document_ref = excluded.document_ref,
+        capture = excluded.capture,
+        method = excluded.method,
+        method_lc = excluded.method_lc,
+        url = excluded.url,
+        url_lc = excluded.url_lc,
+        hostname = excluded.hostname,
+        hostname_lc = excluded.hostname_lc,
+        path = excluded.path,
+        path_lc = excluded.path_lc,
+        status = excluded.status,
+        status_text = excluded.status_text,
+        resource_type = excluded.resource_type,
+        navigation_request = excluded.navigation_request,
+        request_headers_json = excluded.request_headers_json,
+        response_headers_json = excluded.response_headers_json,
+${bodyUpdateSql}        initiator_json = excluded.initiator_json,
+        timing_json = excluded.timing_json,
+        transfer_json = excluded.transfer_json,
+        source_json = excluded.source_json,
+        capture_state = excluded.capture_state,
+        redirect_from_request_id = excluded.redirect_from_request_id,
+        redirect_to_request_id = excluded.redirect_to_request_id,
+        saved_at = MIN(saved_network_records.saved_at, excluded.saved_at)
+    `;
+}
+function inflateSavedNetworkRow(row, includeBodies) {
+  const requestBody = includeBodies && row.request_body_json !== null ? JSON.parse(row.request_body_json) : void 0;
+  const responseBody = includeBodies && row.response_body_json !== null ? JSON.parse(row.response_body_json) : void 0;
+  const record = {
+    kind: "http",
+    requestId: row.request_id,
+    sessionRef: row.session_ref,
+    method: row.method,
+    url: row.url,
+    requestHeaders: JSON.parse(row.request_headers_json),
+    responseHeaders: JSON.parse(row.response_headers_json),
+    resourceType: row.resource_type,
+    navigationRequest: row.navigation_request === 1,
+    captureState: row.capture_state,
+    requestBodyState: row.request_body_state,
+    responseBodyState: row.response_body_state
+  };
+  if (row.page_ref !== null) {
+    record.pageRef = row.page_ref;
+  }
+  if (row.frame_ref !== null) {
+    record.frameRef = row.frame_ref;
+  }
+  if (row.document_ref !== null) {
+    record.documentRef = row.document_ref;
+  }
+  if (row.status !== null) {
+    record.status = row.status;
+  }
+  if (row.status_text !== null) {
+    record.statusText = row.status_text;
+  }
+  if (row.redirect_from_request_id !== null) {
+    record.redirectFromRequestId = row.redirect_from_request_id;
+  }
+  if (row.redirect_to_request_id !== null) {
+    record.redirectToRequestId = row.redirect_to_request_id;
+  }
+  if (row.initiator_json !== null) {
+    record.initiator = JSON.parse(row.initiator_json);
+  }
+  if (row.timing_json !== null) {
+    record.timing = JSON.parse(row.timing_json);
+  }
+  if (row.transfer_json !== null) {
+    record.transfer = JSON.parse(row.transfer_json);
+  }
+  if (row.source_json !== null) {
+    record.source = JSON.parse(row.source_json);
+  }
+  if (row.request_body_skip_reason !== null) {
+    record.requestBodySkipReason = row.request_body_skip_reason;
+  }
+  if (row.response_body_skip_reason !== null) {
+    record.responseBodySkipReason = row.response_body_skip_reason;
+  }
+  if (row.request_body_error !== null) {
+    record.requestBodyError = row.request_body_error;
+  }
+  if (row.response_body_error !== null) {
+    record.responseBodyError = row.response_body_error;
+  }
+  if (requestBody !== void 0) {
+    record.requestBody = requestBody;
+  }
+  if (responseBody !== void 0) {
+    record.responseBody = responseBody;
+  }
+  return {
+    recordId: row.record_id,
+    ...row.capture === null ? {} : { capture: row.capture },
+    ...row.tags === null || row.tags.length === 0 ? {} : { tags: row.tags.split(TAG_DELIMITER).filter((tag) => tag.length > 0) },
+    savedAt: row.saved_at,
+    record
+  };
+}
+function stringifyOptional(value) {
+  return value === void 0 ? null : JSON.stringify(value);
+}
+function normalizeSqliteImportError(error) {
+  if (error instanceof Error && error.code === "ERR_UNKNOWN_BUILTIN_MODULE" && error.message.includes(NODE_SQLITE_SPECIFIER)) {
+    return new Error(SAVED_NETWORK_SQLITE_SUPPORT_ERROR, {
+      cause: error
+    });
+  }
+  return error instanceof Error ? error : new Error(String(error));
+}
+function closeSqliteDatabase(database) {
+  try {
+    database.close();
+  } catch {
+  }
+}
+function withSqliteTransaction(database, task) {
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const result = task();
+    database.exec("COMMIT");
+    return result;
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
+function createSavedNetworkStore(rootPath) {
+  return new SqliteSavedNetworkStore(rootPath);
+}
+function normalizeContext(context) {
+  return {
+    ...context?.sessionRef === void 0 ? {} : { sessionRef: context.sessionRef },
+    ...context?.pageRef === void 0 ? {} : { pageRef: context.pageRef },
+    ...context?.frameRef === void 0 ? {} : { frameRef: context.frameRef },
+    ...context?.documentRef === void 0 ? {} : { documentRef: context.documentRef },
+    ...context?.documentEpoch === void 0 ? {} : { documentEpoch: context.documentEpoch }
+  };
+}
+function sequenceFileName(sequence) {
+  return `${String(sequence).padStart(12, "0")}.json`;
+}
+var FilesystemTraceStore = class {
+  constructor(rootPath, artifacts) {
+    this.rootPath = rootPath;
+    this.artifacts = artifacts;
+    this.runsDirectory = path7.join(this.rootPath, "traces", "runs");
+  }
+  runsDirectory;
+  async initialize() {
+    await ensureDirectory(this.runsDirectory);
+  }
+  async createRun(input = {}) {
+    const runId = normalizeNonEmptyString("runId", input.runId ?? `run:${randomUUID()}`);
+    const manifestPath = this.runManifestPath(runId);
+    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
+    const manifest = {
+      runId,
+      createdAt,
+      updatedAt: createdAt,
+      entryCount: 0
+    };
+    await ensureDirectory(this.runEntriesDirectory(runId));
+    try {
+      await writeJsonFileExclusive(manifestPath, manifest);
+    } catch (error) {
+      if (isAlreadyExistsError(error)) {
+        throw new Error(`trace run ${runId} already exists`);
+      }
+      throw error;
+    }
+    return manifest;
+  }
+  async getRun(runId) {
+    const manifestPath = this.runManifestPath(runId);
+    if (!await pathExists(manifestPath)) {
+      return void 0;
+    }
+    return readJsonFile(manifestPath);
+  }
+  async append(runId, input) {
+    const startedAt = normalizeTimestamp("startedAt", input.startedAt);
+    const completedAt = normalizeTimestamp("completedAt", input.completedAt);
+    if (completedAt < startedAt) {
+      throw new RangeError("completedAt must be greater than or equal to startedAt");
+    }
+    if (input.outcome === "error" && input.error === void 0) {
+      throw new TypeError("error traces must include an error payload");
+    }
+    if (input.outcome === "ok" && input.error !== void 0) {
+      throw new TypeError("successful traces must not include an error payload");
+    }
+    return withFilesystemLock(this.runWriteLockPath(runId), async () => {
+      const manifest = await this.getRun(runId);
+      if (manifest === void 0) {
+        throw new Error(`trace run ${runId} was not found`);
+      }
+      const sequence = manifest.entryCount + 1;
+      const traceId = normalizeNonEmptyString(
+        "traceId",
+        input.traceId ?? `trace:${runId}:${String(sequence).padStart(12, "0")}`
+      );
+      const stepId = normalizeNonEmptyString(
+        "stepId",
+        input.stepId ?? `step:${runId}:${String(sequence).padStart(12, "0")}`
+      );
+      const entry = {
+        runId,
+        sequence,
+        traceId,
+        stepId,
+        operation: normalizeNonEmptyString("operation", input.operation),
+        outcome: input.outcome,
+        startedAt,
+        completedAt,
+        durationMs: completedAt - startedAt,
+        context: normalizeContext(input.context),
+        events: [...input.events ?? []],
+        ...input.artifacts === void 0 || input.artifacts.length === 0 ? {} : { artifacts: [...input.artifacts] },
+        ...input.data === void 0 ? {} : { data: input.data },
+        ...input.error === void 0 ? {} : { error: input.error }
+      };
+      await writeJsonFileExclusive(
+        path7.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
+        entry
+      );
+      await writeJsonFileAtomic(this.runManifestPath(runId), {
+        ...manifest,
+        updatedAt: Math.max(manifest.updatedAt, completedAt),
+        entryCount: sequence
+      });
+      return entry;
+    });
+  }
+  async listEntries(runId) {
+    const entriesDirectory = this.runEntriesDirectory(runId);
+    if (!await pathExists(entriesDirectory)) {
+      return [];
+    }
+    const files = await listJsonFiles(entriesDirectory);
+    return Promise.all(
+      files.map(
+        (fileName) => readJsonFile(path7.join(entriesDirectory, fileName))
+      )
+    );
+  }
+  async getEntry(runId, traceId) {
+    return (await this.listEntries(runId)).find((entry) => entry.traceId === traceId);
+  }
+  toProtocolTraceRecord(entry) {
+    return {
+      traceId: entry.traceId,
+      stepId: entry.stepId,
+      operation: entry.operation,
+      outcome: entry.outcome,
+      startedAt: entry.startedAt,
+      completedAt: entry.completedAt,
+      durationMs: entry.durationMs,
+      context: entry.context,
+      events: entry.events,
+      ...entry.artifacts === void 0 ? {} : { artifacts: entry.artifacts },
+      ...entry.data === void 0 ? {} : { data: entry.data },
+      ...entry.error === void 0 ? {} : { error: entry.error }
+    };
+  }
+  async readProtocolTraceBundle(runId, traceId, options = {}) {
+    const entry = await this.getEntry(runId, traceId);
+    if (entry === void 0) {
+      return void 0;
+    }
+    const trace = this.toProtocolTraceRecord(entry);
+    if (entry.artifacts === void 0 || entry.artifacts.length === 0) {
+      return { trace };
+    }
+    const artifacts = [];
+    for (const reference of entry.artifacts) {
+      const artifact = await this.artifacts.toProtocolArtifact(
+        reference.artifactId,
+        options.artifactDelivery === void 0 ? {} : { delivery: options.artifactDelivery }
+      );
+      if (artifact === void 0) {
+        throw new Error(`trace ${traceId} references missing artifact ${reference.artifactId}`);
+      }
+      artifacts.push(artifact);
+    }
+    return { trace, artifacts };
+  }
+  runDirectory(runId) {
+    return path7.join(this.runsDirectory, encodeURIComponent(runId));
+  }
+  runEntriesDirectory(runId) {
+    return path7.join(this.runDirectory(runId), "entries");
+  }
+  runManifestPath(runId) {
+    return path7.join(this.runDirectory(runId), "manifest.json");
+  }
+  runWriteLockPath(runId) {
+    return path7.join(this.runDirectory(runId), ".append.lock");
+  }
+};
+function createTraceStore(rootPath, artifacts) {
+  return new FilesystemTraceStore(rootPath, artifacts);
+}
+
+// ../runtime-core/src/root.ts
+var OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT = "opensteer-workspace";
+var OPENSTEER_FILESYSTEM_WORKSPACE_VERSION = 2;
+function normalizeWorkspaceId(workspace) {
+  return encodePathSegment(workspace);
+}
+function resolveFilesystemWorkspacePath(input) {
+  return path7.join(
+    input.rootDir,
+    ".opensteer",
+    "workspaces",
+    normalizeWorkspaceId(input.workspace)
+  );
+}
+async function createFilesystemOpensteerWorkspace(options) {
+  await ensureDirectory(options.rootPath);
+  const manifestPath = path7.join(options.rootPath, "workspace.json");
+  const browserPath = path7.join(options.rootPath, "browser");
+  const browserManifestPath = path7.join(browserPath, "manifest.json");
+  const browserUserDataDir = path7.join(browserPath, "user-data");
+  const livePath = path7.join(options.rootPath, "live");
+  const liveLocalPath = path7.join(livePath, "local.json");
+  const liveCloudPath = path7.join(livePath, "cloud.json");
+  const artifactsPath = path7.join(options.rootPath, "artifacts");
+  const tracesPath = path7.join(options.rootPath, "traces");
+  const observationsPath = path7.join(options.rootPath, "observations");
+  const registryPath = path7.join(options.rootPath, "registry");
+  const lockPath = path7.join(options.rootPath, ".lock");
+  let manifest;
+  if (await pathExists(manifestPath)) {
+    manifest = await readJsonFile(manifestPath);
+    if (manifest.layout !== OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT) {
+      throw new Error(
+        `workspace ${options.rootPath} is not an ${OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT} layout`
+      );
+    }
+    if (manifest.version !== OPENSTEER_FILESYSTEM_WORKSPACE_VERSION) {
+      throw new Error(
+        `workspace ${options.rootPath} uses unsupported version ${String(manifest.version)}`
+      );
+    }
+    if (manifest.paths.observations === void 0) {
+      manifest = {
+        ...manifest,
+        updatedAt: Date.now(),
+        paths: {
+          ...manifest.paths,
+          observations: "observations"
+        }
+      };
+      await writeJsonFileAtomic(manifestPath, manifest);
+    }
+  } else {
+    const createdAt = normalizeTimestamp("createdAt", options.createdAt ?? Date.now());
+    manifest = {
+      layout: OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT,
+      version: OPENSTEER_FILESYSTEM_WORKSPACE_VERSION,
+      scope: options.scope ?? (options.workspace === void 0 ? "temporary" : "workspace"),
+      ...options.workspace === void 0 ? {} : { workspace: options.workspace },
+      createdAt,
+      updatedAt: createdAt,
+      paths: {
+        browser: "browser",
+        live: "live",
+        artifacts: "artifacts",
+        traces: "traces",
+        observations: "observations",
+        registry: "registry"
+      }
+    };
+    await writeJsonFileAtomic(manifestPath, manifest);
+  }
+  await Promise.all([
+    ensureDirectory(browserPath),
+    ensureDirectory(browserUserDataDir),
+    ensureDirectory(livePath),
+    ensureDirectory(artifactsPath),
+    ensureDirectory(tracesPath),
+    ensureDirectory(observationsPath),
+    ensureDirectory(registryPath)
+  ]);
+  const artifacts = createArtifactStore(options.rootPath);
+  await artifacts.initialize();
+  const descriptors = createDescriptorRegistry(options.rootPath);
+  await descriptors.initialize();
+  const requestPlans = createRequestPlanRegistry(options.rootPath);
+  await requestPlans.initialize();
+  const savedNetwork = createSavedNetworkStore(options.rootPath);
+  await savedNetwork.initialize();
+  const interactionTraces = createInteractionTraceRegistry(options.rootPath);
+  await interactionTraces.initialize();
+  const traces = createTraceStore(options.rootPath, artifacts);
+  await traces.initialize();
+  const observations = createObservationStore(options.rootPath, artifacts);
+  await observations.initialize();
+  return {
+    rootPath: options.rootPath,
+    manifestPath,
+    manifest,
+    browserPath,
+    browserManifestPath,
+    browserUserDataDir,
+    livePath,
+    liveLocalPath,
+    liveCloudPath,
+    artifactsPath,
+    tracesPath,
+    observationsPath,
+    registryPath,
+    lockPath,
+    artifacts,
+    traces,
+    observations,
+    registry: {
+      descriptors,
+      requestPlans,
+      savedNetwork,
+      interactionTraces
+    },
+    lock(task) {
+      return withFilesystemLock(lockPath, task);
+    }
+  };
+}
+
+// ../runtime-core/src/internal/engine-selection.ts
+var OPENSTEER_ENGINE_NAMES = ["playwright", "abp"];
+var DEFAULT_OPENSTEER_ENGINE = "playwright";
+function resolveOpensteerEngineName(input = {}) {
+  if (input.requested !== void 0) {
+    return normalizeOpensteerEngineName(input.requested, "--engine");
+  }
+  if (input.environment !== void 0) {
+    return normalizeOpensteerEngineName(input.environment, "OPENSTEER_ENGINE");
+  }
+  return DEFAULT_OPENSTEER_ENGINE;
+}
+function normalizeOpensteerEngineName(value, source = "engine") {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "playwright" || normalized === "abp") {
+    return normalized;
+  }
+  throw new Error(
+    `${source} must be one of ${OPENSTEER_ENGINE_NAMES.join(", ")}; received "${value}".`
+  );
+}
+function assertSupportedEngineOptions(input) {
+  if (input.engineName !== "abp") {
+    return;
+  }
+  if (typeof input.browser === "object" && input.browser !== null && input.browser.mode === "attach") {
+    throw new Error(
+      'ABP engine does not support browser.mode="attach". Use the Playwright engine for attach flows.'
+    );
+  }
+  const unsupportedContextOptionNames = listUnsupportedContextOptionNames(input.context);
+  if (unsupportedContextOptionNames.length === 0) {
+    return;
+  }
+  throw new Error(
+    `ABP engine does not support ${unsupportedContextOptionNames.join(", ")}. Supported ABP context options: context.viewport.`
+  );
+}
+function toAbpLaunchOptions(input) {
+  const mapped = {};
+  if (input.launch?.headless !== void 0) {
+    mapped.headless = input.launch.headless;
+  }
+  const args = mergeManagedLaunchArgs(input.launch?.args, input.context?.viewport);
+  if (args !== void 0) {
+    mapped.args = args;
+  }
+  if (input.launch?.executablePath !== void 0) {
+    mapped.browserExecutablePath = input.launch.executablePath;
+  }
+  if (input.userDataDir !== void 0) {
+    mapped.userDataDir = input.userDataDir;
+  }
+  if (input.sessionDir !== void 0) {
+    mapped.sessionDir = input.sessionDir;
+  }
+  return Object.keys(mapped).length === 0 ? void 0 : mapped;
+}
+function listUnsupportedContextOptionNames(options) {
+  if (options === void 0) {
+    return [];
+  }
+  return Object.entries(options).filter(([key, value]) => value !== void 0 && key !== "viewport").map(([key]) => `context.${key}`);
+}
+function mergeManagedLaunchArgs(args, viewport) {
+  const filtered = stripWindowSizeArgs(args);
+  if (viewport === void 0 || viewport === null) {
+    return filtered.length === 0 ? void 0 : filtered;
+  }
+  return [...filtered, `--window-size=${viewport.width},${viewport.height}`];
+}
+function stripWindowSizeArgs(args) {
+  if (args === void 0) {
+    return [];
+  }
+  const filtered = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--window-size") {
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("--window-size=")) {
+      continue;
+    }
+    filtered.push(argument);
+  }
+  return filtered;
+}
+var CHROME_SINGLETON_ARTIFACTS = [
+  "SingletonCookie",
+  "SingletonLock",
+  "SingletonSocket",
+  "DevToolsActivePort",
+  "lockfile"
+];
+async function clearChromeSingletonEntries(userDataDir) {
+  await Promise.all(
+    CHROME_SINGLETON_ARTIFACTS.map(
+      (entry) => rm(join(userDataDir, entry), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0)
+    )
+  );
+}
+async function sanitizeChromeProfile(userDataDir) {
+  const entries = await readdir(userDataDir).catch(() => []);
+  const profileDirs = entries.filter(
+    (entry) => entry === "Default" || /^Profile \d+$/i.test(entry)
+  );
+  await Promise.all(profileDirs.map((dir) => sanitizeProfilePreferences(userDataDir, dir)));
+}
+async function sanitizeProfilePreferences(userDataDir, profileDir) {
+  const prefsPath = join(userDataDir, profileDir, "Preferences");
+  try {
+    const raw = await readFile(prefsPath, "utf8");
+    const prefs = JSON.parse(raw);
+    const profile = prefs.profile ?? {};
+    if (profile.exit_type === "Normal" && profile.exited_cleanly === true) {
+      return;
+    }
+    profile.exit_type = "Normal";
+    profile.exited_cleanly = true;
+    prefs.profile = profile;
+    await writeFile(prefsPath, JSON.stringify(prefs), "utf8");
+    await rm(join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
+      () => void 0
+    );
+  } catch {
+  }
+}
+var CHROME_SINGLETON_ENTRIES = new Set(CHROME_SINGLETON_ARTIFACTS);
+var SKIPPED_ROOT_DIRECTORIES = /* @__PURE__ */ new Set([
+  "Crash Reports",
+  "Crashpad",
+  "BrowserMetrics",
+  "GrShaderCache",
+  "ShaderCache",
+  "GraphiteDawnCache",
+  "component_crx_cache",
+  "Crowd Deny",
+  "hyphen-data",
+  "OnDeviceHeadSuggestModel",
+  "OptimizationGuidePredictionModels",
+  "Segmentation Platform",
+  "SmartCardDeviceNames",
+  "WidevineCdm",
+  "pnacl"
+]);
+var SESSION_ROOT_FILES = /* @__PURE__ */ new Set(["Local State"]);
+var SESSION_SKIPPED_PROFILE_DIRECTORIES = /* @__PURE__ */ new Set([
+  "Cache",
+  "Code Cache",
+  "GPUCache",
+  "Service Worker",
+  "File System",
+  "blob_storage",
+  "Network"
+]);
+async function createBrowserProfileSnapshot(input) {
+  const sourceUserDataDir = resolve(expandHome(input.sourceUserDataDir));
+  const targetUserDataDir = resolve(expandHome(input.targetUserDataDir));
+  const profileDirectory = input.profileDirectory?.trim();
+  const copyMode = input.copyMode;
+  await mkdir(targetUserDataDir, { recursive: true });
+  await clearChromeSingletonEntries(targetUserDataDir);
+  if (profileDirectory) {
+    const sourceProfileDir = join(sourceUserDataDir, profileDirectory);
+    if (!existsSync(sourceProfileDir)) {
+      throw new Error(
+        `Chrome profile "${profileDirectory}" was not found in "${sourceUserDataDir}".`
+      );
+    }
+    await cp(sourceProfileDir, join(targetUserDataDir, profileDirectory), {
+      recursive: true,
+      filter: (candidate) => shouldCopyEntry({
+        candidatePath: candidate,
+        copyMode,
+        rootPath: sourceProfileDir
+      })
+    });
+  }
+  await copyRootLevelEntries({
+    copyMode,
+    sourceUserDataDir,
+    targetUserDataDir,
+    ...profileDirectory === void 0 ? {} : { selectedProfileDirectory: profileDirectory }
+  });
+  await clearChromeSingletonEntries(targetUserDataDir);
+  await sanitizeChromeProfile(targetUserDataDir);
+}
+async function copyRootLevelEntries(input) {
+  const entries = await readdir(input.sourceUserDataDir).catch(() => []);
+  for (const entry of entries) {
+    if (CHROME_SINGLETON_ENTRIES.has(entry) || entry === input.selectedProfileDirectory) {
+      continue;
+    }
+    const sourcePath = join(input.sourceUserDataDir, entry);
+    const targetPath = join(input.targetUserDataDir, entry);
+    const entryStat = await stat(sourcePath).catch(() => null);
+    if (!entryStat) {
+      continue;
+    }
+    if (entryStat.isFile()) {
+      if (input.copyMode === "session" && !SESSION_ROOT_FILES.has(entry)) {
+        continue;
+      }
+      await copyFile(sourcePath, targetPath).catch(() => void 0);
+      continue;
+    }
+    if (!entryStat.isDirectory()) {
+      continue;
+    }
+    if (SKIPPED_ROOT_DIRECTORIES.has(entry) || isProfileDirectory(input.sourceUserDataDir, entry)) {
+      continue;
+    }
+    if (input.copyMode === "session") {
+      continue;
+    }
+    await cp(sourcePath, targetPath, {
+      recursive: true,
+      filter: (candidate) => shouldCopyEntry({
+        candidatePath: candidate,
+        copyMode: input.copyMode,
+        rootPath: sourcePath
+      })
+    }).catch(() => void 0);
+  }
+}
+function isProfileDirectory(userDataDir, entry) {
+  return existsSync(join(userDataDir, entry, "Preferences"));
+}
+function shouldCopyEntry(input) {
+  const entryName = input.candidatePath.split("/").at(-1)?.split("\\").at(-1) ?? input.candidatePath;
+  if (CHROME_SINGLETON_ENTRIES.has(entryName)) {
+    return false;
+  }
+  if (input.copyMode !== "session") {
+    return true;
+  }
+  const relativePath = relative(input.rootPath, input.candidatePath);
+  if (relativePath.length === 0) {
+    return true;
+  }
+  const firstSegment = relativePath.split("/").at(0)?.split("\\").at(0) ?? relativePath;
+  return !SESSION_SKIPPED_PROFILE_DIRECTORIES.has(firstSegment);
+}
+
+// src/local-browser/stealth-init-script.ts
+function generateStealthInitScript(profile) {
+  const encodedProfile = JSON.stringify({
+    ...profile,
+    platformString: getPlatformString(profile.platform),
+    userAgentData: buildUserAgentData(profile)
+  });
+  return `(() => {
+  const profile = ${encodedProfile};
+  var define = function(target, key, value) {
+    Object.defineProperty(target, key, {
+      configurable: true,
+      get: typeof value === 'function' ? value : function() { return value; },
+    });
+  };
+
+  // --- navigator / screen mirrors for future pages ---
+  if (navigator.webdriver === true) {
+    Object.defineProperty(Navigator.prototype, 'webdriver', {
+      configurable: true,
+      get: function() { return false; },
+    });
+  }
+  define(Navigator.prototype, 'platform', profile.platformString);
+  define(Navigator.prototype, 'userAgent', profile.userAgent);
+  define(Navigator.prototype, 'language', profile.locale);
+  define(Navigator.prototype, 'languages', [profile.locale, 'en']);
+  define(Navigator.prototype, 'maxTouchPoints', profile.maxTouchPoints);
+  define(window, 'devicePixelRatio', profile.devicePixelRatio);
+  define(window.screen, 'width', profile.screenResolution.width);
+  define(window.screen, 'height', profile.screenResolution.height);
+  define(window.screen, 'availWidth', profile.screenResolution.width);
+  define(window.screen, 'availHeight', profile.screenResolution.height - 40);
+  define(window.screen, 'colorDepth', 24);
+  define(window.screen, 'pixelDepth', 24);
+  define(Navigator.prototype, 'userAgentData', {
+    brands: profile.userAgentData.brands,
+    mobile: false,
+    platform: profile.userAgentData.platform,
+    toJSON: function() {
+      return {
+        brands: this.brands,
+        mobile: this.mobile,
+        platform: this.platform,
+      };
+    },
+    getHighEntropyValues: async function(hints) {
+      var source = {
+        architecture: profile.userAgentData.architecture,
+        bitness: profile.userAgentData.bitness,
+        brands: profile.userAgentData.brands,
+        fullVersionList: profile.userAgentData.fullVersionList,
+        mobile: false,
+        model: '',
+        platform: profile.userAgentData.platform,
+        platformVersion: profile.userAgentData.platformVersion,
+        uaFullVersion: profile.browserVersion,
+        wow64: false,
+      };
+      var values = {};
+      for (var i = 0; i < hints.length; i++) {
+        var hint = hints[i];
+        if (Object.prototype.hasOwnProperty.call(source, hint)) {
+          values[hint] = source[hint];
+        }
+      }
+      return values;
+    },
+  });
+
+  if (typeof Intl !== 'undefined' && Intl.DateTimeFormat) {
+    var originalResolvedOptions = Intl.DateTimeFormat.prototype.resolvedOptions;
+    Intl.DateTimeFormat.prototype.resolvedOptions = function() {
+      var options = originalResolvedOptions.call(this);
+      options.timeZone = profile.timezoneId;
+      return options;
+    };
+  }
+
+  if (Date.prototype.getTimezoneOffset) {
+    var originalGetTimezoneOffset = Date.prototype.getTimezoneOffset;
+    var calculateTimezoneOffset = function(date) {
+      try {
+        var formatter = new Intl.DateTimeFormat('en-US', {
+          timeZone: profile.timezoneId,
+          hour12: false,
+          year: 'numeric',
+          month: '2-digit',
+          day: '2-digit',
+          hour: '2-digit',
+          minute: '2-digit',
+          second: '2-digit',
+        });
+        var parts = formatter.formatToParts(date);
+        var values = {};
+        for (var i = 0; i < parts.length; i++) {
+          if (parts[i].type !== 'literal') {
+            values[parts[i].type] = Number(parts[i].value);
+          }
+        }
+        var utcTime = Date.UTC(
+          values.year,
+          values.month - 1,
+          values.day,
+          values.hour,
+          values.minute,
+          values.second,
+        );
+        return Math.round((date.getTime() - utcTime) / 60000);
+      } catch {
+        return originalGetTimezoneOffset.call(date);
+      }
+    };
+    Date.prototype.getTimezoneOffset = function() {
+      return calculateTimezoneOffset(this);
+    };
+  }
+
+  // --- CDP Runtime.enable leak defense ---
+  var _wrap = function(name) {
+    var orig = console[name];
+    if (typeof orig !== 'function') return;
+    console[name] = new Proxy(orig, {
+      apply: function(target, thisArg, args) {
+        for (var i = 0; i < args.length; i++) {
+          if (args[i] instanceof Error) {
+            var d = Object.getOwnPropertyDescriptor(args[i], 'stack');
+            if (d && typeof d.get === 'function') return undefined;
+          }
+        }
+        return Reflect.apply(target, thisArg, args);
+      },
+    });
+  };
+  ['debug', 'log', 'info', 'error', 'warn', 'trace', 'dir'].forEach(_wrap);
+
+  // --- Canvas fingerprint noise ---
+  var seedNoise = function(seed, input) {
+    var value = Math.sin(seed + input * 12.9898) * 43758.5453;
+    return value - Math.floor(value);
+  };
+  if (HTMLCanvasElement.prototype.toDataURL) {
+    var originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
+    HTMLCanvasElement.prototype.toDataURL = function() {
+      var context = this.getContext('2d');
+      if (context) {
+        var x = Math.min(1, Math.max(0, this.width - 1));
+        var y = Math.min(1, Math.max(0, this.height - 1));
+        var imageData = context.getImageData(x, y, 1, 1);
+        imageData.data[0] = Math.max(0, Math.min(255, imageData.data[0] + Math.floor(seedNoise(profile.canvasNoiseSeed, 1) * 2)));
+        context.putImageData(imageData, x, y);
+      }
+      return originalToDataURL.apply(this, arguments);
+    };
+  }
+
+  // --- WebGL vendor/renderer spoofing ---
+  if (typeof WebGLRenderingContext !== 'undefined') {
+    var originalGetParameter = WebGLRenderingContext.prototype.getParameter;
+    WebGLRenderingContext.prototype.getParameter = function(parameter) {
+      if (parameter === 37445) return profile.webglVendor;
+      if (parameter === 37446) return profile.webglRenderer;
+      return originalGetParameter.call(this, parameter);
+    };
+  }
+
+  // --- AudioBuffer fingerprint noise ---
+  if (typeof AudioBuffer !== 'undefined' && typeof AnalyserNode !== 'undefined') {
+    var originalGetFloatFrequencyData = AnalyserNode.prototype.getFloatFrequencyData;
+    AnalyserNode.prototype.getFloatFrequencyData = function(array) {
+      originalGetFloatFrequencyData.call(this, array);
+      for (var index = 0; index < array.length; index += 16) {
+        array[index] += (seedNoise(profile.audioNoiseSeed, index) - 0.5) * 0.0001;
+      }
+    };
+  }
+
+  // --- Font availability spoofing ---
+  if (document.fonts && typeof document.fonts.check === 'function') {
+    var originalCheck = document.fonts.check.bind(document.fonts);
+    document.fonts.check = function(font, text) {
+      var family = String(font).match(/["']([^"']+)["']/)?.[1] || String(font).split(/\\s+/).at(-1);
+      if (family && profile.fonts.includes(family)) {
+        return true;
+      }
+      return originalCheck(font, text);
+    };
+  }
+})();`;
+}
+function buildUserAgentData(profile) {
+  const majorVersion = profile.browserVersion.split(".")[0] ?? "136";
+  const platformData = {
+    macos: { platform: "macOS", platformVersion: "14.4.0", architecture: "arm" },
+    windows: { platform: "Windows", platformVersion: "15.0.0", architecture: "x86" },
+    linux: { platform: "Linux", platformVersion: "6.5.0", architecture: "x86" }
+  };
+  const platformInfo = platformData[profile.platform];
+  return {
+    architecture: platformInfo.architecture,
+    bitness: "64",
+    brands: [
+      { brand: "Chromium", version: majorVersion },
+      ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: majorVersion }] : [{ brand: "Google Chrome", version: majorVersion }],
+      { brand: "Not-A.Brand", version: "99" }
+    ],
+    fullVersionList: [
+      { brand: "Chromium", version: profile.browserVersion },
+      ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: profile.browserVersion }] : [{ brand: "Google Chrome", version: profile.browserVersion }],
+      { brand: "Not-A.Brand", version: "99.0.0.0" }
+    ],
+    platform: platformInfo.platform,
+    platformVersion: platformInfo.platformVersion
+  };
+}
+function getPlatformString(platform) {
+  return platform === "macos" ? "MacIntel" : platform === "windows" ? "Win32" : "Linux x86_64";
+}
+
+// src/local-browser/stealth.ts
+var STEALTH_INIT_SCRIPT = `(() => {
+  // Override navigator.webdriver only if Chrome reports automation.
+  // --disable-blink-features=AutomationControlled should prevent this, but some
+  // Chrome builds still set webdriver=true when --remote-debugging-port is active.
+  if (navigator.webdriver === true) {
+    Object.defineProperty(Navigator.prototype, 'webdriver', {
+      get: function() { return false; },
+      configurable: true,
+    });
+  }
+
+  // Neutralize CDP Runtime.enable leak detection.
+  //
+  // Playwright enables the CDP Runtime domain for page.evaluate(). Bot detectors
+  // exploit this: they create an Error with a user-defined getter on its 'stack'
+  // property, then pass that Error to a console method. When Runtime.enable is
+  // active, Chrome serializes the Error for the Runtime.consoleAPICalled event,
+  // which triggers the getter \u2014 proving CDP is present.
+  //
+  // Defense: wrap console methods in a Proxy that detects this specific pattern
+  // (an Error whose 'stack' is an accessor, not a data property) and suppresses
+  // the call. Normal Errors have a plain data-property 'stack', so legitimate
+  // console usage is unaffected.
+  var _wrap = function(name) {
+    var orig = console[name];
+    if (typeof orig !== 'function') return;
+    console[name] = new Proxy(orig, {
+      apply: function(target, thisArg, args) {
+        for (var i = 0; i < args.length; i++) {
+          if (args[i] instanceof Error) {
+            var d = Object.getOwnPropertyDescriptor(args[i], 'stack');
+            if (d && typeof d.get === 'function') return undefined;
+          }
+        }
+        return Reflect.apply(target, thisArg, args);
+      },
+    });
+  };
+  ['debug', 'log', 'info', 'error', 'warn', 'trace', 'dir'].forEach(_wrap);
+})();`;
+async function injectBrowserStealthScripts(context, input = {}) {
+  if (input.profile !== void 0) {
+    await installContextNetworkHeaders(context, input.profile);
+    await installCdpStealthOverrides(context, input.profile, input.page);
+  }
+  if (typeof context.addInitScript === "function") {
+    await context.addInitScript({
+      content: input.profile === void 0 ? STEALTH_INIT_SCRIPT : generateStealthInitScript(input.profile)
+    });
+  }
+}
+function buildUserAgentMetadata(profile) {
+  const majorVersion = profile.browserVersion.split(".")[0] ?? "136";
+  const brands = [
+    { brand: "Chromium", version: majorVersion },
+    ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: majorVersion }] : [{ brand: "Google Chrome", version: majorVersion }],
+    { brand: "Not-A.Brand", version: "99" }
+  ];
+  const fullVersionList = [
+    { brand: "Chromium", version: profile.browserVersion },
+    ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: profile.browserVersion }] : [{ brand: "Google Chrome", version: profile.browserVersion }],
+    { brand: "Not-A.Brand", version: "99.0.0.0" }
+  ];
+  const platformMap = {
+    // Chromium keeps the reduced macOS UA token frozen to Intel even on Apple Silicon.
+    macos: { platform: "macOS", platformVersion: "14.4.0", architecture: "arm" },
+    windows: { platform: "Windows", platformVersion: "15.0.0", architecture: "x86" },
+    linux: { platform: "Linux", platformVersion: "6.5.0", architecture: "x86" }
+  };
+  const platformInfo = platformMap[profile.platform];
+  return {
+    brands,
+    fullVersionList,
+    platform: platformInfo.platform,
+    platformVersion: platformInfo.platformVersion,
+    architecture: platformInfo.architecture,
+    model: "",
+    mobile: false,
+    bitness: "64",
+    wow64: false
+  };
+}
+async function installCdpStealthOverrides(context, profile, initialPage) {
+  const pages = initialPage === void 0 ? context.pages() : Array.from(/* @__PURE__ */ new Set([initialPage, ...context.pages()]));
+  await Promise.all(pages.map((page) => applyPageOverrides(context, page, profile)));
+  const appliedPages = /* @__PURE__ */ new WeakSet();
+  const applyFuturePageOverrides = async (page) => {
+    if (appliedPages.has(page)) {
+      return;
+    }
+    appliedPages.add(page);
+    await applyPageOverrides(context, page, profile);
+  };
+  if (typeof context.on === "function") {
+    context.on("page", applyFuturePageOverrides);
+  }
+}
+async function installContextNetworkHeaders(context, profile) {
+  if (typeof context.setExtraHTTPHeaders !== "function") {
+    return;
+  }
+  await context.setExtraHTTPHeaders(buildStealthRequestHeaders(profile)).catch(() => void 0);
+}
+async function applyPageOverrides(context, page, profile) {
+  const contextWithCdp = context;
+  if (typeof contextWithCdp.newCDPSession !== "function") {
+    return;
+  }
+  let cdp;
+  try {
+    cdp = await contextWithCdp.newCDPSession(page);
+  } catch {
+    return;
+  }
+  try {
+    await applyCdpStealthCommands((method, params) => cdp.send(method, params), profile);
+  } catch {
+  } finally {
+    await cdp.detach().catch(() => void 0);
+  }
+}
+async function applyCdpStealthCommands(send, profile) {
+  await send("Network.setUserAgentOverride", {
+    userAgent: profile.userAgent,
+    acceptLanguage: `${profile.locale},en;q=0.9`,
+    platform: getPlatformString2(profile.platform),
+    userAgentMetadata: buildUserAgentMetadata(profile)
+  });
+  await send("Emulation.setDeviceMetricsOverride", {
+    width: profile.viewport.width,
+    height: profile.viewport.height,
+    deviceScaleFactor: profile.devicePixelRatio,
+    mobile: false,
+    screenWidth: profile.screenResolution.width,
+    screenHeight: profile.screenResolution.height
+  });
+  await send("Emulation.setLocaleOverride", {
+    locale: profile.locale
+  }).catch(() => void 0);
+  await send("Emulation.setTimezoneOverride", {
+    timezoneId: profile.timezoneId
+  }).catch(() => void 0);
+}
+function buildStealthRequestHeaders(profile) {
+  const metadata = buildUserAgentMetadata(profile);
+  return {
+    "Accept-Language": `${profile.locale},en;q=0.9`,
+    "Sec-CH-UA": metadata.brands.map(formatClientHintBrand).join(", "),
+    "Sec-CH-UA-Mobile": "?0",
+    "Sec-CH-UA-Platform": `"${metadata.platform}"`,
+    "User-Agent": profile.userAgent
+  };
+}
+function formatClientHintBrand(brand) {
+  return `"${brand.brand}";v="${brand.version}"`;
+}
+function getPlatformString2(platform) {
+  return platform === "macos" ? "MacIntel" : platform === "windows" ? "Win32" : "Linux x86_64";
+}
+
+// src/local-browser/stealth-profiles.ts
+var PROFILE_PRESETS = [
+  {
+    platform: "macos",
+    browserBrand: "chrome",
+    browserVersion: "136.0.7103.93",
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+    viewport: { width: 1440, height: 900 },
+    screenResolution: { width: 1512, height: 982 },
+    devicePixelRatio: 2,
+    maxTouchPoints: 0,
+    webglVendor: "Apple",
+    webglRenderer: "Apple M2",
+    fonts: ["SF Pro Text", "Helvetica Neue", "Arial", "Menlo", "Apple Color Emoji"],
+    locale: "en-US",
+    timezoneId: "America/Los_Angeles"
+  },
+  {
+    platform: "windows",
+    browserBrand: "chrome",
+    browserVersion: "136.0.7103.93",
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+    viewport: { width: 1536, height: 864 },
+    screenResolution: { width: 1920, height: 1080 },
+    devicePixelRatio: 1.25,
+    maxTouchPoints: 0,
+    webglVendor: "Google Inc. (Intel)",
+    webglRenderer: "ANGLE (Intel, Intel(R) Iris(R) Xe Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)",
+    fonts: ["Segoe UI", "Arial", "Calibri", "Consolas", "Segoe UI Emoji"],
+    locale: "en-US",
+    timezoneId: "America/New_York"
+  },
+  {
+    platform: "windows",
+    browserBrand: "edge",
+    browserVersion: "136.0.3240.50",
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.3240.50",
+    viewport: { width: 1536, height: 864 },
+    screenResolution: { width: 1920, height: 1080 },
+    devicePixelRatio: 1.25,
+    maxTouchPoints: 0,
+    webglVendor: "Google Inc. (Intel)",
+    webglRenderer: "ANGLE (Intel, Intel(R) UHD Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)",
+    fonts: ["Segoe UI", "Arial", "Calibri", "Consolas", "Segoe UI Emoji"],
+    locale: "en-US",
+    timezoneId: "America/Chicago"
+  },
+  {
+    platform: "linux",
+    browserBrand: "chrome",
+    browserVersion: "136.0.7103.93",
+    userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+    viewport: { width: 1366, height: 768 },
+    screenResolution: { width: 1366, height: 768 },
+    devicePixelRatio: 1,
+    maxTouchPoints: 0,
+    webglVendor: "Google Inc. (Mesa)",
+    webglRenderer: "ANGLE (AMD, AMD Radeon Graphics, OpenGL 4.6)",
+    fonts: ["Noto Sans", "Ubuntu", "DejaVu Sans", "Liberation Sans", "Noto Color Emoji"],
+    locale: "en-US",
+    timezoneId: "UTC"
+  }
+];
+function generateStealthProfile(overrides = {}) {
+  const preset = pickStealthProfilePreset(overrides);
+  return {
+    id: overrides.id ?? `stealth:${preset.platform}:${preset.browserBrand}:${Math.random().toString(36).slice(2, 10)}`,
+    platform: overrides.platform ?? preset.platform,
+    browserBrand: overrides.browserBrand ?? preset.browserBrand,
+    browserVersion: overrides.browserVersion ?? preset.browserVersion,
+    userAgent: overrides.userAgent ?? preset.userAgent,
+    viewport: overrides.viewport ?? preset.viewport,
+    screenResolution: overrides.screenResolution ?? preset.screenResolution,
+    devicePixelRatio: overrides.devicePixelRatio ?? preset.devicePixelRatio,
+    maxTouchPoints: overrides.maxTouchPoints ?? preset.maxTouchPoints,
+    webglVendor: overrides.webglVendor ?? preset.webglVendor,
+    webglRenderer: overrides.webglRenderer ?? preset.webglRenderer,
+    fonts: overrides.fonts ?? preset.fonts,
+    canvasNoiseSeed: overrides.canvasNoiseSeed ?? Math.floor(Math.random() * 1e6),
+    audioNoiseSeed: overrides.audioNoiseSeed ?? Math.floor(Math.random() * 1e6),
+    locale: overrides.locale ?? preset.locale,
+    timezoneId: overrides.timezoneId ?? preset.timezoneId
+  };
+}
+function pickStealthProfilePreset(overrides) {
+  const candidates = PROFILE_PRESETS.filter(
+    (preset) => (overrides.platform === void 0 || preset.platform === overrides.platform) && (overrides.browserBrand === void 0 || preset.browserBrand === overrides.browserBrand)
+  );
+  const pool = candidates.length > 0 ? candidates : PROFILE_PRESETS;
+  return pool[Math.floor(Math.random() * pool.length)];
+}
+
+// src/local-view/preferences.ts
+var OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT = "opensteer-local-view-preferences";
+var OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION = 1;
+async function resolveLocalViewMode() {
+  const preferences = await readLocalViewPreferences();
+  return preferences?.mode ?? "auto";
+}
+async function setLocalViewMode(mode) {
+  return writeLocalViewPreferences(mode);
+}
+async function readLocalViewPreferences() {
+  const preferencesPath = resolveLocalViewPreferencesPath();
+  if (!await pathExists(preferencesPath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(preferencesPath);
+  return isPersistedLocalViewPreferences(parsed) ? parsed : void 0;
+}
+async function writeLocalViewPreferences(mode) {
+  const preferences = {
+    layout: OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT,
+    version: OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION,
+    mode,
+    updatedAt: Date.now()
+  };
+  await writeJsonFileAtomic(resolveLocalViewPreferencesPath(), preferences);
+  return preferences;
+}
+function isPersistedLocalViewPreferences(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION && (value.mode === "auto" || value.mode === "manual") && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+}
+var LOCK_OWNER_FILE = "owner.json";
+var LOCK_RECLAIMER_DIR = "reclaimer";
+var LOCK_RETRY_DELAY_MS = 50;
+async function acquireDirLock(lockDirPath) {
+  while (true) {
+    const releaseLock = await tryAcquireDirLock(lockDirPath);
+    if (releaseLock) {
+      return releaseLock;
+    }
+    await sleep(LOCK_RETRY_DELAY_MS);
+  }
+}
+async function tryAcquireDirLock(lockDirPath) {
+  await mkdir(dirname(lockDirPath), { recursive: true });
+  while (true) {
+    const tempLockDirPath = `${lockDirPath}-${String(process.pid)}-${String(CURRENT_PROCESS_OWNER.processStartedAtMs)}-${randomUUID()}`;
+    try {
+      await mkdir(tempLockDirPath);
+      await writeLockOwner(tempLockDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await rename(tempLockDirPath, lockDirPath);
+        break;
+      } catch (error) {
+        if (!wasDirPublishedByAnotherProcess(error, lockDirPath)) {
+          throw error;
+        }
+      }
+    } finally {
+      await rm(tempLockDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const owner = await readLockOwner(lockDirPath);
+    if ((!owner || await getProcessLiveness(owner) === "dead") && await tryReclaimStaleLock(lockDirPath, owner)) {
+      continue;
+    }
+    return null;
+  }
+  return async () => {
+    await rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  };
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function wasDirPublishedByAnotherProcess(error, targetDirPath) {
+  const code = getErrorCode(error);
+  return existsSync(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+}
+async function writeLockOwner(lockDirPath, owner) {
+  await writeFile(join(lockDirPath, LOCK_OWNER_FILE), JSON.stringify(owner));
+}
+async function readLockOwner(lockDirPath) {
+  return readLockParticipant(join(lockDirPath, LOCK_OWNER_FILE));
+}
+async function readLockParticipant(filePath) {
+  return (await readLockParticipantRecord(filePath)).owner;
+}
+async function readLockParticipantRecord(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return {
+      exists: true,
+      owner: parseProcessOwner(JSON.parse(raw))
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode(error) !== "ENOENT",
+      owner: null
+    };
+  }
+}
+async function readLockReclaimerRecord(lockDirPath) {
+  return readLockParticipantRecord(join(buildLockReclaimerDirPath(lockDirPath), LOCK_OWNER_FILE));
+}
+async function tryReclaimStaleLock(lockDirPath, expectedOwner) {
+  if (!await tryAcquireLockReclaimer(lockDirPath)) {
+    return false;
+  }
+  let reclaimed = false;
+  try {
+    const owner = await readLockOwner(lockDirPath);
+    if (!processOwnersEqual(owner, expectedOwner)) {
+      return false;
+    }
+    if (owner && await getProcessLiveness(owner) !== "dead") {
+      return false;
+    }
+    await rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+    reclaimed = !existsSync(lockDirPath);
+    return reclaimed;
+  } finally {
+    if (!reclaimed) {
+      await rm(buildLockReclaimerDirPath(lockDirPath), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function tryAcquireLockReclaimer(lockDirPath) {
+  const reclaimerDirPath = buildLockReclaimerDirPath(lockDirPath);
+  while (true) {
+    const tempReclaimerDirPath = `${reclaimerDirPath}-${String(process.pid)}-${String(CURRENT_PROCESS_OWNER.processStartedAtMs)}-${randomUUID()}`;
+    try {
+      await mkdir(tempReclaimerDirPath);
+      await writeLockOwner(tempReclaimerDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await rename(tempReclaimerDirPath, reclaimerDirPath);
+        return true;
+      } catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+          return false;
+        }
+        if (!wasDirPublishedByAnotherProcess(error, reclaimerDirPath)) {
+          throw error;
+        }
+      }
+    } catch (error) {
+      if (getErrorCode(error) === "ENOENT") {
+        return false;
+      }
+      throw error;
+    } finally {
+      await rm(tempReclaimerDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const reclaimerRecord = await readLockReclaimerRecord(lockDirPath);
+    if (!reclaimerRecord.exists || !reclaimerRecord.owner) {
+      return false;
+    }
+    if (await getProcessLiveness(reclaimerRecord.owner) !== "dead") {
+      return false;
+    }
+    await rm(reclaimerDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+function buildLockReclaimerDirPath(lockDirPath) {
+  return join(lockDirPath, LOCK_RECLAIMER_DIR);
+}
+async function sleep(ms) {
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/local-view/service.ts
+var LOCAL_VIEW_STARTUP_TIMEOUT_MS = 1e4;
+var LOCAL_VIEW_STARTUP_POLL_MS = 100;
+var LOCAL_VIEW_STOP_TIMEOUT_MS = 1e4;
+async function ensureLocalViewServiceRunning() {
+  const current = await readReachableLocalViewServiceState();
+  if (current !== void 0) {
+    return current;
+  }
+  const releaseLock = await acquireDirLock(resolveLocalViewServiceLockDir());
+  try {
+    const lockedState = await readReachableLocalViewServiceState();
+    if (lockedState !== void 0) {
+      return lockedState;
+    }
+    await spawnLocalViewService();
+    const started = await waitForLocalViewService();
+    if (!started) {
+      throw new Error("Timed out while starting the local view service.");
+    }
+    return started;
+  } finally {
+    await releaseLock();
+  }
+}
+async function stopLocalViewService() {
+  const state = await readLocalViewServiceState();
+  if (state === void 0 || !await isLocalViewServiceStateLive(state)) {
+    await clearLocalViewServiceState(
+      state === void 0 ? void 0 : { pid: state.pid, token: state.token }
+    );
+    return false;
+  }
+  const liveState = state;
+  const stopRequested = await requestLocalViewServiceStop(liveState).catch(() => false);
+  if (!stopRequested && await getLocalViewServiceStateLiveness(liveState) !== "dead") {
+    process.kill(liveState.pid);
+  }
+  await waitForLocalViewServiceStop(liveState);
+  await clearLocalViewServiceState({ pid: liveState.pid, token: liveState.token });
+  return true;
+}
+function buildLocalViewSessionUrl(args) {
+  if (!args.sessionId) {
+    return args.baseUrl;
+  }
+  return `${args.baseUrl}#session=${encodeURIComponent(args.sessionId)}`;
+}
+async function requestLocalViewServiceStop(state) {
+  const response = await fetch(new URL("/api/service/stop", state.url), {
+    method: "POST",
+    headers: {
+      "x-opensteer-local-token": state.token
+    }
+  });
+  return response.ok;
+}
+async function waitForLocalViewServiceStop(state) {
+  const deadline = Date.now() + LOCAL_VIEW_STOP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await getLocalViewServiceStateLiveness(state) === "dead") {
+      return;
+    }
+    await delay(LOCAL_VIEW_STARTUP_POLL_MS);
+  }
+  throw new Error("Timed out while stopping the local view service.");
+}
+function spawnLocalViewService() {
+  const command = resolveLocalViewSpawnCommand();
+  const child = spawn(command.executable, command.args, {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      ...command.env ?? {},
+      OPENSTEER_LOCAL_VIEW_BOOT_TOKEN: process.env.OPENSTEER_LOCAL_VIEW_BOOT_TOKEN ?? randomBytes(24).toString("hex")
+    },
+    detached: process.platform !== "win32",
+    stdio: "ignore"
+  });
+  child.unref();
+}
+async function waitForLocalViewService() {
+  const deadline = Date.now() + LOCAL_VIEW_STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const state = await readReachableLocalViewServiceState();
+    if (state !== void 0) {
+      return state;
+    }
+    await delay(LOCAL_VIEW_STARTUP_POLL_MS);
+  }
+  return void 0;
+}
+async function readReachableLocalViewServiceState() {
+  const state = await readLocalViewServiceState();
+  if (state === void 0 || !await isLocalViewServiceStateLive(state)) {
+    return void 0;
+  }
+  return await isLocalViewServiceReachable(state.url, state.token) ? state : void 0;
+}
+async function isLocalViewServiceReachable(baseUrl, token) {
+  try {
+    const response = await fetch(new URL("/api/health", baseUrl), {
+      headers: {
+        "x-opensteer-local-token": token
+      }
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function resolveLocalViewSpawnCommand() {
+  const moduleDir = path7.dirname(fileURLToPath(import.meta.url));
+  const distServicePath = findExistingPath([
+    path7.join(moduleDir, "local-view", "serve-entry.js"),
+    path7.join(moduleDir, "serve-entry.js"),
+    path7.join(moduleDir, "..", "local-view", "serve-entry.js")
+  ]);
+  if (distServicePath) {
+    return {
+      executable: process.execPath,
+      args: [distServicePath]
+    };
+  }
+  const distCliPath = findExistingPath([
+    path7.join(moduleDir, "cli", "bin.js"),
+    path7.join(moduleDir, "..", "cli", "bin.js")
+  ]);
+  if (distCliPath) {
+    return {
+      executable: process.execPath,
+      args: [distCliPath, "view", "serve"]
+    };
+  }
+  const srcServicePath = findExistingPath([
+    path7.join(moduleDir, "serve-entry.ts"),
+    path7.join(moduleDir, "..", "local-view", "serve-entry.ts"),
+    path7.join(moduleDir, "..", "src", "local-view", "serve-entry.ts")
+  ]);
+  if (srcServicePath) {
+    const require2 = createRequire(import.meta.url);
+    const tsxLoaderPath = require2.resolve("tsx");
+    const tsconfigPath = findNearestTsconfig(path7.resolve(moduleDir, "..", "..", ".."));
+    return {
+      executable: process.execPath,
+      args: ["--import", tsxLoaderPath, srcServicePath],
+      ...tsconfigPath ? { env: { TSX_TSCONFIG_PATH: tsconfigPath } } : {}
+    };
+  }
+  const srcCliPath = findExistingPath([
+    path7.join(moduleDir, "..", "cli", "bin.ts"),
+    path7.join(moduleDir, "..", "src", "cli", "bin.ts")
+  ]);
+  if (srcCliPath) {
+    const require2 = createRequire(import.meta.url);
+    const tsxLoaderPath = require2.resolve("tsx");
+    const tsconfigPath = findNearestTsconfig(path7.resolve(moduleDir, "..", "..", ".."));
+    return {
+      executable: process.execPath,
+      args: ["--import", tsxLoaderPath, srcCliPath, "view", "serve"],
+      ...tsconfigPath ? { env: { TSX_TSCONFIG_PATH: tsconfigPath } } : {}
+    };
+  }
+  throw new Error(`Could not resolve the Opensteer CLI entrypoint from ${moduleDir}.`);
+}
+function findExistingPath(candidates) {
+  return candidates.find((candidate) => existsSync(candidate));
+}
+function findNearestTsconfig(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const candidate = path7.join(currentDir, "tsconfig.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parentDir = path7.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+
+// src/local-view/registration.ts
+async function bestEffortRegisterLocalViewSession(input) {
+  try {
+    const manifest = createLocalViewSessionManifest(input);
+    await writeLocalViewSessionManifest(manifest);
+    if (await resolveLocalViewMode() === "auto") {
+      void ensureLocalViewServiceRunning().catch(() => void 0);
+    }
+    return manifest;
+  } catch {
+    return void 0;
+  }
+}
+async function bestEffortUnregisterLocalViewSession(sessionId) {
+  if (!sessionId) {
+    return;
+  }
+  await deleteLocalViewSessionManifest(sessionId).catch(() => void 0);
+}
+
+// src/browser-manager.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEVTOOLS_POLL_INTERVAL_MS = 50;
+var TEMPORARY_WORKSPACE_PREFIX = "opensteer-temporary-workspace-";
+var BROWSER_CLOSE_TIMEOUT_MS = 5e3;
+var OpensteerBrowserManager = class {
+  mode;
+  engineName;
+  rootPath;
+  workspace;
+  cleanupRootOnDisconnect;
+  browserOptions;
+  launchOptions;
+  contextOptions;
+  workspaceStore;
+  constructor(options = {}) {
+    this.workspace = normalizeWorkspace(options.workspace);
+    this.mode = resolveBrowserMode(this.workspace, options.browser);
+    this.browserOptions = isAttachBrowserOptions(options.browser) ? options.browser : void 0;
+    this.launchOptions = options.launch;
+    this.contextOptions = normalizeBrowserContextOptions(options.context);
+    this.engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
+    assertSupportedEngineOptions({
+      engineName: this.engineName,
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...this.contextOptions === void 0 ? {} : { context: this.contextOptions }
+    });
+    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7.join(tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${randomUUID()}`) : resolveFilesystemWorkspacePath({
+      rootDir: path7.resolve(options.rootDir ?? process.cwd()),
+      workspace: this.workspace
+    }));
+    this.cleanupRootOnDisconnect = this.workspace === void 0;
+  }
+  async createEngine() {
+    if (this.mode === "persistent") {
+      const effectiveEngine = await this.resolveLivePersistentEngineName() ?? this.engineName;
+      if (effectiveEngine === "abp") {
+        return this.createAbpEngine();
+      }
+      return this.createPersistentEngine();
+    }
+    if (this.engineName === "abp") {
+      return this.createAbpEngine();
+    }
+    if (this.mode === "temporary") {
+      return this.createTemporaryEngine();
+    }
+    if (this.mode === "attach") {
+      return this.createAttachEngine();
+    }
+    return this.createPersistentEngine();
+  }
+  async status() {
+    if (this.mode === "temporary") {
+      return {
+        mode: "temporary",
+        engine: this.engineName,
+        live: false
+      };
+    }
+    const liveRecord = await this.readLivePersistentBrowser(await this.ensureWorkspaceStore());
+    return {
+      mode: this.mode,
+      engine: liveRecord?.engine ?? this.engineName,
+      ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+      live: liveRecord !== void 0
+    };
+  }
+  async clonePersistentBrowser(input) {
+    this.requirePersistentMode("clone");
+    const workspace = await this.ensureWorkspaceStore();
+    return workspace.lock(async () => {
+      await this.assertPersistentBrowserClosed(workspace);
+      await rm(workspace.browserPath, { recursive: true, force: true });
+      await ensureDirectory(workspace.browserUserDataDir);
+      await clearChromeSingletonEntries(workspace.browserUserDataDir);
+      await createBrowserProfileSnapshot({
+        sourceUserDataDir: input.sourceUserDataDir,
+        targetUserDataDir: workspace.browserUserDataDir,
+        ...input.sourceProfileDirectory === void 0 ? {} : { profileDirectory: input.sourceProfileDirectory },
+        copyMode: "full"
+      });
+      const manifest = {
+        mode: "persistent",
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        userDataDir: "browser/user-data",
+        bootstrap: {
+          kind: "cloneLocalProfile",
+          sourceUserDataDir: path7.resolve(input.sourceUserDataDir),
+          ...input.sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory: input.sourceProfileDirectory }
+        }
+      };
+      await writeJsonFileAtomic(workspace.browserManifestPath, manifest);
+      return manifest;
+    });
+  }
+  async reset() {
+    this.requirePersistentMode("reset");
+    const workspace = await this.ensureWorkspaceStore();
+    await workspace.lock(async () => {
+      await this.closePersistentBrowser(workspace);
+      await rm(resolveAbpSessionDir(workspace), { recursive: true, force: true });
+      await rm(workspace.browserPath, { recursive: true, force: true });
+      await clearPersistedSessionRecord(workspace.rootPath, "local");
+      await ensureDirectory(workspace.browserUserDataDir);
+    });
+  }
+  async delete() {
+    this.requirePersistentMode("delete");
+    const workspace = await this.ensureWorkspaceStore();
+    await workspace.lock(async () => {
+      await this.closePersistentBrowser(workspace);
+      await rm(resolveAbpSessionDir(workspace), { recursive: true, force: true });
+      await rm(workspace.browserPath, { recursive: true, force: true });
+      await clearPersistedSessionRecord(workspace.rootPath, "local");
+    });
+  }
+  async close() {
+    if (this.mode !== "persistent") {
+      return;
+    }
+    const workspace = await this.ensureWorkspaceStore();
+    await workspace.lock(async () => {
+      await this.closePersistentBrowser(workspace);
+    });
+  }
+  async createAbpEngine() {
+    if (this.mode === "attach") {
+      throw new Error(
+        'ABP engine does not support browser.mode="attach". Use the Playwright engine for attach flows.'
+      );
+    }
+    if (this.mode === "temporary") {
+      return this.createTemporaryAbpEngine();
+    }
+    return this.createPersistentAbpEngine();
+  }
+  async createTemporaryAbpEngine() {
+    const workspace = await this.ensureWorkspaceStore();
+    await clearChromeSingletonEntries(workspace.browserUserDataDir);
+    const { createAbpBrowserCoreEngine } = await loadAbpModule();
+    const launch = toAbpLaunchOptions({
+      ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
+      ...this.contextOptions === void 0 ? {} : { context: this.contextOptions },
+      userDataDir: workspace.browserUserDataDir,
+      sessionDir: resolveAbpSessionDir(workspace)
+    });
+    return await createAbpBrowserCoreEngine(
+      launch === void 0 ? {} : { launch }
+    );
+  }
+  async createPersistentAbpEngine() {
+    const workspace = await this.ensureWorkspaceStore();
+    return workspace.lock(async () => {
+      const live = await this.readLivePersistentBrowser(workspace);
+      if (live !== void 0) {
+        if (live.engine !== "abp") {
+          throw new Error(
+            `workspace "${this.workspace}" already has a live ${live.engine} browser. Close it before reopening with engine "abp".`
+          );
+        }
+        await bestEffortRegisterLocalViewSession({
+          rootPath: workspace.rootPath,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+          live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+          ownership: "owned"
+        });
+        return this.createAdoptedAbpEngine(live);
+      }
+      await this.ensurePersistentBrowserManifest(workspace);
+      await clearChromeSingletonEntries(workspace.browserUserDataDir);
+      const { launchAbpProcess } = await loadAbpModule();
+      const launch = toAbpLaunchOptions({
+        ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
+        ...this.contextOptions === void 0 ? {} : { context: this.contextOptions },
+        userDataDir: workspace.browserUserDataDir,
+        sessionDir: resolveAbpSessionDir(workspace)
+      });
+      const launched = await launchAbpProcess({
+        port: await allocateEphemeralPort(),
+        userDataDir: workspace.browserUserDataDir,
+        sessionDir: resolveAbpSessionDir(workspace),
+        headless: launch?.headless ?? true,
+        args: launch?.args ?? [],
+        verbose: false,
+        ...launch?.browserExecutablePath === void 0 ? {} : { browserExecutablePath: launch.browserExecutablePath }
+      });
+      const liveRecord = {
+        mode: "persistent",
+        engine: "abp",
+        baseUrl: launched.baseUrl,
+        remoteDebuggingUrl: launched.remoteDebuggingUrl,
+        pid: launched.process.pid ?? 0,
+        startedAt: Date.now(),
+        userDataDir: workspace.browserUserDataDir,
+        sessionDir: resolveAbpSessionDir(workspace),
+        ...launch?.browserExecutablePath === void 0 ? {} : { executablePath: launch.browserExecutablePath }
+      };
+      await this.writeLivePersistentBrowser(workspace, liveRecord);
+      const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+      await bestEffortRegisterLocalViewSession({
+        rootPath: workspace.rootPath,
+        ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+        live: persistedLiveRecord,
+        ownership: "owned"
+      });
+      try {
+        return await this.createAdoptedAbpEngine(liveRecord);
+      } catch (error) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
+        await terminateProcess(launched.process.pid ?? 0).catch(() => void 0);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+        throw error;
+      }
+    });
+  }
+  async createAdoptedAbpEngine(live) {
+    if (live.baseUrl === void 0 || live.remoteDebuggingUrl === void 0) {
+      throw new Error("workspace live browser record is missing ABP connection metadata.");
+    }
+    const { createAbpBrowserCoreEngine } = await loadAbpModule();
+    return await createAbpBrowserCoreEngine({
+      browser: {
+        baseUrl: live.baseUrl,
+        remoteDebuggingUrl: live.remoteDebuggingUrl
+      }
+    });
+  }
+  async createTemporaryEngine() {
+    const userDataDir = await mkdtemp(path7.join(tmpdir(), "opensteer-temporary-browser-"));
+    await clearChromeSingletonEntries(userDataDir);
+    const launched = await launchOwnedBrowser({
+      userDataDir,
+      ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
+      ...this.contextOptions?.viewport === void 0 ? {} : { viewport: this.contextOptions.viewport }
+    });
+    const temporaryLiveRecord = {
+      layout: "opensteer-session",
+      version: 1,
+      provider: "local",
+      engine: "playwright",
+      endpoint: launched.endpoint,
+      pid: launched.pid,
+      startedAt: Date.now(),
+      updatedAt: Date.now(),
+      executablePath: launched.executablePath,
+      userDataDir
+    };
+    await writePersistedSessionRecord(this.rootPath, temporaryLiveRecord);
+    const localViewManifest = await bestEffortRegisterLocalViewSession({
+      rootPath: this.rootPath,
+      live: temporaryLiveRecord,
+      ownership: "owned"
+    });
+    try {
+      return await this.createAttachedEngine({
+        endpoint: launched.endpoint,
+        freshTab: false,
+        onDispose: async () => {
+          await bestEffortUnregisterLocalViewSession(localViewManifest?.sessionId);
+          await clearPersistedSessionRecord(this.rootPath, "local").catch(() => void 0);
+          await terminateProcess(launched.pid).catch(() => void 0);
+          await rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
+        }
+      });
+    } catch (error) {
+      await bestEffortUnregisterLocalViewSession(localViewManifest?.sessionId);
+      await clearPersistedSessionRecord(this.rootPath, "local").catch(() => void 0);
+      await terminateProcess(launched.pid).catch(() => void 0);
+      await rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
+      throw error;
+    }
+  }
+  async createAttachEngine() {
+    const endpoint = await resolveAttachEndpoint(this.browserOptions);
+    return this.createAttachedEngine({
+      endpoint,
+      ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+      freshTab: this.browserOptions?.freshTab ?? true,
+      onDispose: async () => void 0
+    });
+  }
+  async createPersistentEngine() {
+    const workspace = await this.ensureWorkspaceStore();
+    return workspace.lock(async () => {
+      const live = await this.readLivePersistentBrowser(workspace);
+      if (live) {
+        if (live.engine !== "playwright") {
+          throw new Error(
+            `workspace "${this.workspace}" already has a live ${live.engine} browser. Close it before reopening with engine "playwright".`
+          );
+        }
+        if (live.endpoint === void 0) {
+          throw new Error("workspace live browser record is missing a DevTools endpoint.");
+        }
+        await bestEffortRegisterLocalViewSession({
+          rootPath: workspace.rootPath,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+          live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+          ownership: "owned"
+        });
+        return this.createAttachedEngine({
+          endpoint: live.endpoint,
+          freshTab: false,
+          onDispose: async () => void 0
+        });
+      }
+      await this.ensurePersistentBrowserManifest(workspace);
+      const launched = await launchOwnedBrowser({
+        userDataDir: workspace.browserUserDataDir,
+        ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
+        ...this.contextOptions?.viewport === void 0 ? {} : { viewport: this.contextOptions.viewport }
+      });
+      const liveRecord = {
+        mode: "persistent",
+        engine: "playwright",
+        endpoint: launched.endpoint,
+        pid: launched.pid,
+        startedAt: Date.now(),
+        executablePath: launched.executablePath,
+        userDataDir: workspace.browserUserDataDir
+      };
+      await this.writeLivePersistentBrowser(workspace, liveRecord);
+      const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+      await bestEffortRegisterLocalViewSession({
+        rootPath: workspace.rootPath,
+        ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+        live: persistedLiveRecord,
+        ownership: "owned"
+      });
+      try {
+        return await this.createAttachedEngine({
+          endpoint: launched.endpoint,
+          freshTab: false,
+          onDispose: async () => void 0
+        });
+      } catch (error) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
+        await terminateProcess(launched.pid).catch(() => void 0);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+        throw error;
+      }
+    });
+  }
+  async createAttachedEngine(input) {
+    const browser = await connectPlaywrightChromiumBrowser({
+      url: input.endpoint,
+      ...input.headers === void 0 ? {} : { headers: input.headers }
+    });
+    try {
+      const context = browser.contexts()[0];
+      if (!context) {
+        throw new Error("Connected browser did not expose a Chromium browser context.");
+      }
+      const page = input.freshTab || context.pages()[0] === void 0 ? await context.newPage() : context.pages()[0];
+      await page.bringToFront?.();
+      const stealthProfile = resolveStealthProfile(this.contextOptions?.stealthProfile);
+      await injectBrowserStealthScripts(
+        context,
+        stealthProfile === void 0 ? {} : {
+          profile: stealthProfile,
+          page
+        }
+      );
+      const engine = await createPlaywrightBrowserCoreEngine({
+        browser,
+        attachedContext: context,
+        attachedPage: page,
+        closeAttachedContextOnSessionClose: false,
+        closeBrowserOnDispose: false,
+        ...this.contextOptions === void 0 ? {} : { context: toEngineBrowserContextOptions(this.contextOptions) }
+      });
+      const originalDispose = engine.dispose?.bind(engine);
+      const originalAsyncDispose = engine[Symbol.asyncDispose]?.bind(engine);
+      let disposed = false;
+      const disposeConnection = async () => {
+        if (disposed) {
+          return;
+        }
+        disposed = true;
+        try {
+          await originalDispose?.();
+        } finally {
+          await disconnectPlaywrightChromiumBrowser(browser).catch(() => void 0);
+          await input.onDispose().catch(() => void 0);
+        }
+      };
+      engine.dispose = disposeConnection;
+      engine[Symbol.asyncDispose] = async () => {
+        if (disposed) {
+          return;
+        }
+        disposed = true;
+        try {
+          await originalAsyncDispose?.();
+        } finally {
+          await disconnectPlaywrightChromiumBrowser(browser).catch(() => void 0);
+          await input.onDispose().catch(() => void 0);
+        }
+      };
+      return engine;
+    } catch (error) {
+      await disconnectPlaywrightChromiumBrowser(browser).catch(() => void 0);
+      throw error;
+    }
+  }
+  async ensureWorkspaceStore() {
+    this.workspaceStore ??= await createFilesystemOpensteerWorkspace({
+      rootPath: this.rootPath,
+      ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+      scope: this.workspace === void 0 ? "temporary" : "workspace"
+    });
+    return this.workspaceStore;
+  }
+  async ensurePersistentBrowserManifest(workspace) {
+    const existing = await this.readBrowserManifest(workspace);
+    if (existing) {
+      return existing;
+    }
+    const now = Date.now();
+    const manifest = {
+      mode: "persistent",
+      createdAt: now,
+      updatedAt: now,
+      userDataDir: "browser/user-data",
+      bootstrap: {
+        kind: "empty"
+      }
+    };
+    await ensureDirectory(workspace.browserUserDataDir);
+    await writeJsonFileAtomic(workspace.browserManifestPath, manifest);
+    return manifest;
+  }
+  async readBrowserManifest(workspace) {
+    if (!await pathExists(workspace.browserManifestPath)) {
+      return void 0;
+    }
+    return readJsonFile(workspace.browserManifestPath);
+  }
+  async readLivePersistentBrowser(workspace) {
+    const live = await this.readStoredLiveBrowser(workspace);
+    if (live === void 0) {
+      return void 0;
+    }
+    if (!isProcessRunning(live.pid)) {
+      await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+      return void 0;
+    }
+    if (live.engine === "playwright") {
+      if (live.endpoint === void 0 || !await isEndpointReachable(live.endpoint)) {
+        throw new Error(
+          `workspace "${this.workspace}" browser process ${String(live.pid)} is still running, but its DevTools endpoint is unavailable`
+        );
+      }
+      return live;
+    }
+    if (live.baseUrl === void 0 || !await isAbpBaseUrlReachable(live.baseUrl)) {
+      throw new Error(
+        `workspace "${this.workspace}" browser process ${String(live.pid)} is still running, but its ABP endpoint is unavailable`
+      );
+    }
+    return live;
+  }
+  async readStoredLiveBrowser(workspace) {
+    const live = await readPersistedLocalBrowserSessionRecord(workspace.rootPath);
+    return live === void 0 ? void 0 : toWorkspaceLiveBrowserRecord(live);
+  }
+  async resolveLivePersistentEngineName() {
+    if (this.mode !== "persistent") {
+      return void 0;
+    }
+    const workspace = await this.ensureWorkspaceStore();
+    const live = await this.readStoredLiveBrowser(workspace);
+    return live?.engine;
+  }
+  async assertPersistentBrowserClosed(workspace) {
+    if (await this.readLivePersistentBrowser(workspace) !== void 0) {
+      throw new Error(
+        `workspace "${this.workspace}" already has a live browser. Close it before changing the saved profile.`
+      );
+    }
+  }
+  async closePersistentBrowser(workspace) {
+    const live = await this.readStoredLiveBrowser(workspace);
+    if (!live) {
+      await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+      return;
+    }
+    await this.unregisterLocalViewSessionForRecord(
+      workspace.rootPath,
+      toPersistedLocalBrowserSessionRecord(this.workspace, live)
+    );
+    if (live.engine === "playwright") {
+      if (live.endpoint !== void 0) {
+        await requestBrowserClose(live.endpoint).catch(() => void 0);
+      }
+      if (await waitForProcessExit(live.pid, BROWSER_CLOSE_TIMEOUT_MS)) {
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+        return;
+      }
+      await terminateProcess(live.pid).catch(() => void 0);
+      await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+      return;
+    }
+    await terminateProcess(live.pid).catch(() => void 0);
+    await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+  }
+  async writeLivePersistentBrowser(workspace, live) {
+    await writePersistedSessionRecord(
+      workspace.rootPath,
+      toPersistedLocalBrowserSessionRecord(this.workspace, live)
+    );
+  }
+  requirePersistentMode(method) {
+    if (this.mode !== "persistent" || this.workspace === void 0) {
+      throw new Error(`browser.${method}() requires a persistent workspace browser.`);
+    }
+  }
+  async unregisterLocalViewSessionForRecord(rootPath, record) {
+    await bestEffortUnregisterLocalViewSession(
+      buildLocalViewSessionId({
+        rootPath,
+        pid: record.pid,
+        startedAt: record.startedAt
+      })
+    );
+  }
+};
+function normalizeWorkspace(workspace) {
+  const normalized = workspace?.trim();
+  return normalized === void 0 || normalized.length === 0 ? void 0 : normalized;
+}
+function toPersistedLocalBrowserSessionRecord(workspace, live) {
+  return {
+    layout: "opensteer-session",
+    version: 1,
+    provider: "local",
+    ...workspace === void 0 ? {} : { workspace },
+    engine: live.engine,
+    ...live.endpoint === void 0 ? {} : { endpoint: live.endpoint },
+    ...live.baseUrl === void 0 ? {} : { baseUrl: live.baseUrl },
+    ...live.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: live.remoteDebuggingUrl },
+    ...live.sessionDir === void 0 ? {} : { sessionDir: live.sessionDir },
+    pid: live.pid,
+    startedAt: live.startedAt,
+    updatedAt: Date.now(),
+    ...live.executablePath === void 0 ? {} : { executablePath: live.executablePath },
+    userDataDir: live.userDataDir
+  };
+}
+function toWorkspaceLiveBrowserRecord(record) {
+  return {
+    mode: "persistent",
+    engine: record.engine,
+    ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
+    ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
+    ...record.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: record.remoteDebuggingUrl },
+    ...record.sessionDir === void 0 ? {} : { sessionDir: record.sessionDir },
+    pid: record.pid,
+    startedAt: record.startedAt,
+    ...record.executablePath === void 0 ? {} : { executablePath: record.executablePath },
+    userDataDir: record.userDataDir
+  };
+}
+function resolveBrowserMode(workspace, browser) {
+  if (browser === void 0) {
+    return workspace === void 0 ? "temporary" : "persistent";
+  }
+  if (browser === "temporary" || browser === "persistent") {
+    return browser;
+  }
+  return "attach";
+}
+function isAttachBrowserOptions(browser) {
+  return typeof browser === "object" && browser !== null && browser.mode === "attach";
+}
+async function resolveAttachEndpoint(browser) {
+  const endpoint = browser?.endpoint?.trim();
+  if (endpoint && endpoint.length > 0) {
+    return endpoint;
+  }
+  const selection = await selectAttachBrowserCandidate({
+    timeoutMs: DEFAULT_TIMEOUT_MS
+  });
+  return selection.endpoint;
+}
+async function launchOwnedBrowser(input) {
+  await ensureDirectory(input.userDataDir);
+  await clearChromeSingletonEntries(input.userDataDir);
+  await sanitizeChromeProfile(input.userDataDir);
+  const requestedRemoteDebuggingPort = readRequestedRemoteDebuggingPort(input.launch?.args);
+  const executablePath = resolveChromeExecutablePath(input.launch?.executablePath);
+  const args = buildChromeArgs(
+    input.userDataDir,
+    input.launch,
+    input.viewport,
+    requestedRemoteDebuggingPort
+  );
+  const child = spawn(executablePath, args, {
+    stdio: ["ignore", "ignore", "pipe"],
+    detached: process.platform !== "win32"
+  });
+  child.unref();
+  const stderrLines = [];
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    stderrLines.push(String(chunk));
+  });
+  child.stderr?.unref?.();
+  const endpoint = await waitForDevToolsEndpoint({
+    userDataDir: input.userDataDir,
+    timeoutMs: input.launch?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    childExited: async () => child.exitCode,
+    stderrLines,
+    ...requestedRemoteDebuggingPort !== void 0 && requestedRemoteDebuggingPort > 0 ? { requestedRemoteDebuggingPort } : {}
+  }).catch(async (error) => {
+    child.kill("SIGKILL");
+    throw error;
+  });
+  return {
+    endpoint,
+    pid: child.pid ?? 0,
+    executablePath
+  };
+}
+function buildChromeArgs(userDataDir, launch, viewport, requestedRemoteDebuggingPort) {
+  const isHeadless = launch?.headless ?? true;
+  const args = [
+    ...requestedRemoteDebuggingPort === void 0 ? ["--remote-debugging-port=0"] : [],
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-blink-features=AutomationControlled",
+    "--disable-background-networking",
+    "--disable-backgrounding-occluded-windows",
+    "--disable-component-update",
+    "--disable-default-apps",
+    "--disable-hang-monitor",
+    "--disable-popup-blocking",
+    "--disable-prompt-on-repost",
+    "--disable-sync",
+    "--disable-infobars",
+    "--disable-features=Translate",
+    "--enable-features=NetworkService,NetworkServiceInProcess",
+    "--password-store=basic",
+    "--use-mock-keychain",
+    `--user-data-dir=${userDataDir}`
+  ];
+  if (isHeadless) {
+    args.push("--headless=new");
+  }
+  const hasUserWindowSize = (launch?.args ?? []).some((entry) => entry.startsWith("--window-size"));
+  if (!hasUserWindowSize) {
+    const width = viewport?.width ?? 1440;
+    const height = viewport?.height ?? 900;
+    args.push(
+      isHeadless ? `--window-size=${String(width)},${String(height)}` : `--window-size=${String(width)},${String(height + 150)}`
+    );
+  }
+  args.push(...launch?.args ?? []);
+  if (!(launch?.args ?? []).some((entry) => !entry.startsWith("-"))) {
+    args.push("about:blank");
+  }
+  return args;
+}
+async function waitForDevToolsEndpoint(input) {
+  const deadline = Date.now() + input.timeoutMs;
+  while (Date.now() < deadline) {
+    const activePort = readDevToolsActivePort(input.userDataDir);
+    if (activePort) {
+      try {
+        const inspected = await inspectCdpEndpoint({
+          endpoint: `http://127.0.0.1:${String(activePort.port)}`,
+          timeoutMs: Math.min(2e3, input.timeoutMs)
+        });
+        return inspected.endpoint;
+      } catch {
+        return `ws://127.0.0.1:${String(activePort.port)}${activePort.webSocketPath}`;
+      }
+    }
+    if (input.requestedRemoteDebuggingPort !== void 0) {
+      const endpoint = await tryInspectRemoteDebuggingPort(
+        input.requestedRemoteDebuggingPort,
+        input.timeoutMs
+      );
+      if (endpoint !== void 0) {
+        return endpoint;
+      }
+    }
+    const exitCode = await input.childExited();
+    if (exitCode !== null) {
+      throw new Error(formatChromeLaunchError(input.stderrLines));
+    }
+    await sleep2(DEVTOOLS_POLL_INTERVAL_MS);
+  }
+  throw new Error(formatChromeLaunchError(input.stderrLines));
+}
+function readRequestedRemoteDebuggingPort(args) {
+  if (args === void 0 || args.length === 0) {
+    return void 0;
+  }
+  let explicitFlagFound = false;
+  let port;
+  for (let index = 0; index < args.length; index += 1) {
+    const entry = args[index];
+    if (entry === "--remote-debugging-port") {
+      explicitFlagFound = true;
+      const next = args[index + 1];
+      if (next !== void 0) {
+        port = parseRemoteDebuggingPort(next);
+        index += 1;
+      }
+      continue;
+    }
+    if (entry.startsWith("--remote-debugging-port=")) {
+      explicitFlagFound = true;
+      port = parseRemoteDebuggingPort(entry.slice("--remote-debugging-port=".length));
+    }
+  }
+  return explicitFlagFound ? port : void 0;
+}
+function parseRemoteDebuggingPort(value) {
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    return void 0;
+  }
+  return parsed;
+}
+async function tryInspectRemoteDebuggingPort(port, timeoutMs) {
+  try {
+    const inspected = await inspectCdpEndpoint({
+      endpoint: `http://127.0.0.1:${String(port)}`,
+      timeoutMs: Math.min(2e3, timeoutMs)
+    });
+    return inspected.endpoint;
+  } catch {
+    return void 0;
+  }
+}
+function formatChromeLaunchError(stderrLines) {
+  const collapsed = stderrLines.join("").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (collapsed.length === 0) {
+    return "Chrome failed to launch before exposing a DevTools endpoint.";
+  }
+  return `Chrome failed to launch before exposing a DevTools endpoint.
+${collapsed.slice(-5).join("\n")}`;
+}
+async function isEndpointReachable(endpoint) {
+  try {
+    await inspectCdpEndpoint({
+      endpoint,
+      timeoutMs: 1500
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isAbpBaseUrlReachable(baseUrl) {
+  try {
+    const response = await fetch(`${baseUrl}/browser/status`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function terminateProcess(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  if (await waitForProcessExit(pid, BROWSER_CLOSE_TIMEOUT_MS)) {
+    return;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return;
+  }
+}
+async function requestBrowserClose(endpoint) {
+  await new Promise((resolve2, reject) => {
+    const socket = new WebSocket(endpoint);
+    const timeout = setTimeout(() => {
+      socket.close();
+      reject(new Error("Timed out waiting for Browser.close."));
+    }, BROWSER_CLOSE_TIMEOUT_MS);
+    let settled = false;
+    const finish = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve2();
+    };
+    socket.addEventListener("open", () => {
+      socket.send(JSON.stringify({ id: 1, method: "Browser.close" }));
+    });
+    socket.addEventListener("message", (event) => {
+      try {
+        const message = JSON.parse(String(event.data));
+        if (message.id !== 1) {
+          return;
+        }
+        finish(message.error?.message === void 0 ? void 0 : new Error(message.error.message));
+      } catch (error) {
+        finish(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    socket.addEventListener("close", () => {
+      finish();
+    });
+    socket.addEventListener("error", () => {
+      finish(new Error("Failed to send Browser.close."));
+    });
+  });
+}
+async function waitForProcessExit(pid, timeoutMs) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return true;
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(pid)) {
+      return true;
+    }
+    await sleep2(50);
+  }
+  return !isProcessRunning(pid);
+}
+function resolveAbpSessionDir(workspace) {
+  return path7.join(workspace.livePath, "abp-session");
+}
+async function allocateEphemeralPort() {
+  const { allocatePort } = await loadAbpModule();
+  return allocatePort();
+}
+async function loadAbpModule() {
+  try {
+    return await import('@opensteer/engine-abp');
+  } catch (error) {
+    if (isMissingPackageError(error, "@opensteer/engine-abp")) {
+      throw new Error(
+        'ABP engine selected but "@opensteer/engine-abp" is not installed. Install it to use --engine abp or OPENSTEER_ENGINE=abp.'
+      );
+    }
+    throw error;
+  }
+}
+function isMissingPackageError(error, packageName) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes(`Cannot find package '${packageName}'`) || error.message.includes(`Cannot find module '${packageName}'`) || error.message.includes(`Cannot find module "${packageName}"`);
+}
+function normalizeBrowserContextOptions(context) {
+  const stealthProfile = resolveStealthProfile(context?.stealthProfile);
+  const locale = context?.locale ?? stealthProfile?.locale;
+  const timezoneId = context?.timezoneId ?? stealthProfile?.timezoneId;
+  const userAgent = context?.userAgent ?? stealthProfile?.userAgent;
+  return {
+    ...context ?? {},
+    ...stealthProfile === void 0 ? {} : { stealthProfile },
+    ...locale === void 0 ? {} : { locale },
+    ...timezoneId === void 0 ? {} : { timezoneId },
+    ...userAgent === void 0 ? {} : { userAgent },
+    viewport: context?.viewport ?? stealthProfile?.viewport ?? {
+      width: 1440,
+      height: 900
+    }
+  };
+}
+function toEngineBrowserContextOptions(context) {
+  const { stealthProfile: _stealthProfile, ...engineContext } = context;
+  return engineContext;
+}
+function resolveStealthProfile(input) {
+  if (input === void 0) {
+    return void 0;
+  }
+  if (isStealthProfile(input)) {
+    return input;
+  }
+  return generateStealthProfile(input);
+}
+function isStealthProfile(input) {
+  return input.id !== void 0 && input.platform !== void 0 && input.browserBrand !== void 0 && input.browserVersion !== void 0 && input.userAgent !== void 0 && input.viewport !== void 0 && input.screenResolution !== void 0 && input.devicePixelRatio !== void 0 && input.maxTouchPoints !== void 0 && input.webglVendor !== void 0 && input.webglRenderer !== void 0 && input.fonts !== void 0 && input.canvasNoiseSeed !== void 0 && input.audioNoiseSeed !== void 0 && input.locale !== void 0 && input.timezoneId !== void 0;
+}
+async function sleep2(ms) {
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+export { DEFAULT_OPENSTEER_ENGINE, OPENSTEER_ENGINE_NAMES, OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT, OPENSTEER_FILESYSTEM_WORKSPACE_VERSION, OpensteerBrowserManager, assertSupportedEngineOptions, buildLocalViewSessionUrl, createArtifactStore, createFilesystemOpensteerWorkspace, createObservationStore, ensureLocalViewServiceRunning, manifestToExternalBinaryLocation, normalizeObservabilityConfig, normalizeObservationContext, normalizeOpensteerEngineName, normalizeWorkspaceId, resolveFilesystemWorkspacePath, resolveOpensteerEngineName, setLocalViewMode, stopLocalViewService };
+//# sourceMappingURL=chunk-2TIVULZY.js.map
+//# sourceMappingURL=chunk-2TIVULZY.js.map