opensteer 0.8.18 → 0.9.0

package/dist/index.cjs

@@ -2507,7 +2507,7 @@ objectSchema(
   }
 );
 var opensteerSessionFetchTransportSchema = enumSchema(
-  ["auto", "direct", "matched-tls", "page"],
+  ["auto", "direct", "matched-tls", "context", "page"],
   {
     title: "OpensteerSessionFetchTransport"
   }
@@ -6860,6 +6860,7 @@ var opensteerSemanticOperationSpecificationsBase = [
         case "direct":
           return [];
         case "matched-tls":
+        case "context":
           return ["inspect.cookies"];
         case "page":
           return ["pages.manage"];
@@ -7481,13 +7482,6 @@ var SqliteSavedNetworkStore = class {
   }
   async save(records, options) {
     const database = await this.requireDatabase();
-    const readExisting = database.prepare(`
-        SELECT record_id
-        FROM saved_network_records
-        WHERE session_ref = @session_ref
-          AND page_ref_key = @page_ref_key
-          AND request_id = @request_id
-      `);
     const upsertRecord = database.prepare(buildSavedNetworkUpsertSql(options.bodyWriteMode));
     const insertTag = database.prepare(`
       INSERT OR IGNORE INTO saved_network_tags (record_id, tag)
@@ -7498,14 +7492,8 @@ var SqliteSavedNetworkStore = class {
       for (const entry of records) {
         const url = new URL(entry.record.url);
         const pageRefKey = entry.record.pageRef ?? "";
-        const existing = readExisting.get({
-          session_ref: entry.record.sessionRef,
-          page_ref_key: pageRefKey,
-          request_id: entry.record.requestId
-        }) ?? void 0;
-        const recordId = existing?.record_id ?? entry.recordId;
         upsertRecord.run({
-          record_id: recordId,
+          record_id: entry.recordId,
           request_id: entry.record.requestId,
           session_ref: entry.record.sessionRef,
           page_ref: entry.record.pageRef ?? null,
@@ -7550,7 +7538,7 @@ var SqliteSavedNetworkStore = class {
         }
         for (const currentTag of tags) {
           const result = insertTag.run({
-            record_id: recordId,
+            record_id: entry.recordId,
             tag: currentTag
           });
           savedCount += result.changes ?? 0;
@@ -7653,6 +7641,49 @@ var SqliteSavedNetworkStore = class {
       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;
@@ -7737,15 +7768,6 @@ var SqliteSavedNetworkStore = class {
         saved_at INTEGER NOT NULL
       );
 
-      CREATE UNIQUE INDEX IF NOT EXISTS saved_network_records_scope_request
-        ON saved_network_records (session_ref, page_ref_key, request_id);
-
-      CREATE INDEX IF NOT EXISTS saved_network_records_saved_at
-        ON saved_network_records (saved_at DESC);
-
-      CREATE INDEX IF NOT EXISTS saved_network_records_capture
-        ON saved_network_records (capture);
-
       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,
@@ -7755,6 +7777,19 @@ var SqliteSavedNetworkStore = class {
       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",
@@ -8942,7 +8977,6 @@ var DEFAULT_TIMEOUTS = {
   "dom.extract": 15e3,
   "network.query": 15e3,
   "network.detail": 15e3,
-  "network.replay": 3e4,
   "scripts.capture": 15e3,
   "session.cookies": 1e4,
   "session.storage": 1e4,
@@ -15977,8 +16011,14 @@ 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);
+  const args = buildChromeArgs(
+    input.userDataDir,
+    input.launch,
+    input.viewport,
+    requestedRemoteDebuggingPort
+  );
   const child = child_process.spawn(executablePath, args, {
     stdio: ["ignore", "ignore", "pipe"],
     detached: process.platform !== "win32"
@@ -15994,7 +16034,8 @@ async function launchOwnedBrowser(input) {
     userDataDir: input.userDataDir,
     timeoutMs: input.launch?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     childExited: async () => child.exitCode,
-    stderrLines
+    stderrLines,
+    ...requestedRemoteDebuggingPort !== void 0 && requestedRemoteDebuggingPort > 0 ? { requestedRemoteDebuggingPort } : {}
   }).catch(async (error) => {
     child.kill("SIGKILL");
     throw error;
@@ -16005,10 +16046,10 @@ async function launchOwnedBrowser(input) {
     executablePath
   };
 }
-function buildChromeArgs(userDataDir, launch, viewport) {
+function buildChromeArgs(userDataDir, launch, viewport, requestedRemoteDebuggingPort) {
   const isHeadless = launch?.headless ?? true;
   const args = [
-    "--remote-debugging-port=0",
+    ...requestedRemoteDebuggingPort === void 0 ? ["--remote-debugging-port=0"] : [],
     "--no-first-run",
     "--no-default-browser-check",
     "--disable-blink-features=AutomationControlled",
@@ -16059,6 +16100,15 @@ async function waitForDevToolsEndpoint(input) {
         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));
@@ -16067,6 +16117,52 @@ async function waitForDevToolsEndpoint(input) {
   }
   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) {
@@ -16791,21 +16887,24 @@ var OpensteerCloudClient = class {
   getConfig() {
     return this.config;
   }
-  async createSession(input = {}) {
-    const response = await this.request("/v1/sessions", {
-      method: "POST",
-      body: {
-        ...input.name === void 0 ? {} : { name: input.name },
-        ...input.browser === void 0 ? {} : { browser: input.browser },
-        ...input.context === void 0 ? {} : { context: input.context },
-        ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile },
-        ...input.observability === void 0 ? {} : { observability: input.observability },
-        ...input.sourceType === void 0 ? {} : { sourceType: input.sourceType },
-        ...input.sourceRef === void 0 ? {} : { sourceRef: input.sourceRef },
-        ...input.localWorkspaceRootPath === void 0 ? {} : { localWorkspaceRootPath: input.localWorkspaceRootPath },
-        ...input.locality === void 0 ? {} : { locality: input.locality }
-      }
-    });
+  async createSession(input = {}, options = {}) {
+    const response = await this.request(
+      "/v1/sessions",
+      {
+        method: "POST",
+        body: {
+          ...input.name === void 0 ? {} : { name: input.name },
+          ...input.browser === void 0 ? {} : { browser: input.browser },
+          ...input.context === void 0 ? {} : { context: input.context },
+          ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile },
+          ...input.observability === void 0 ? {} : { observability: input.observability },
+          ...input.sourceType === void 0 ? {} : { sourceType: input.sourceType },
+          ...input.sourceRef === void 0 ? {} : { sourceRef: input.sourceRef },
+          ...input.localWorkspaceRootPath === void 0 ? {} : { localWorkspaceRootPath: input.localWorkspaceRootPath }
+        }
+      },
+      options
+    );
     return await response.json();
   }
   async listSessions() {
@@ -16814,19 +16913,27 @@ var OpensteerCloudClient = class {
     });
     return response.json();
   }
-  async getSession(sessionId) {
-    const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}`, {
-      method: "GET"
-    });
+  async getSession(sessionId, options = {}) {
+    const response = await this.request(
+      `/v1/sessions/${encodeURIComponent(sessionId)}`,
+      {
+        method: "GET"
+      },
+      options
+    );
     return await response.json();
   }
-  async issueAccess(sessionId, capabilities) {
-    const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}/access`, {
-      method: "POST",
-      body: {
-        capabilities
-      }
-    });
+  async issueAccess(sessionId, capabilities, options = {}) {
+    const response = await this.request(
+      `/v1/sessions/${encodeURIComponent(sessionId)}/access`,
+      {
+        method: "POST",
+        body: {
+          capabilities
+        }
+      },
+      options
+    );
     return await response.json();
   }
   async getSessionRecording(sessionId) {
@@ -16908,28 +17015,17 @@ var OpensteerCloudClient = class {
   async syncBrowserProfileCookies(input) {
     return syncBrowserProfileCookies(this, input);
   }
-  async importSelectorCache(entries) {
-    const response = await this.request("/selector-cache/import", {
+  async importDescriptors(entries) {
+    const response = await this.request("/registry/descriptors/import", {
       method: "POST",
-      body: {
-        entries: entries.map((entry) => ({
-          workspace: entry.workspace,
-          method: entry.method,
-          persistHash: entry.persistHash,
-          ...entry.persist === void 0 ? {} : { persist: entry.persist },
-          path: entry.path,
-          ...entry.schemaHash === void 0 ? {} : { schemaHash: entry.schemaHash },
-          createdAt: entry.createdAt,
-          updatedAt: entry.updatedAt
-        }))
-      }
+      body: { entries }
     });
     return await response.json();
   }
-  async importDescriptors(entries) {
-    const response = await this.request("/registry/descriptors/import", {
+  async importRequestPlans(input) {
+    const response = await this.request("/registry/request-plans/import", {
       method: "POST",
-      body: { entries }
+      body: input
     });
     return await response.json();
   }
@@ -16942,7 +17038,7 @@ var OpensteerCloudClient = class {
       "content-type": "application/json; charset=utf-8"
     };
   }
-  async request(pathname, init) {
+  async request(pathname, init, options = {}) {
     const url = `${this.config.baseUrl}${pathname}`;
     let response;
     try {
@@ -16950,7 +17046,7 @@ var OpensteerCloudClient = class {
         method: init.method,
         headers: this.buildHeaders(),
         ...init.body === void 0 ? {} : { body: JSON.stringify(init.body) },
-        signal: AbortSignal.timeout(3e4)
+        signal: createRequestSignal(options)
       });
     } catch (error) {
       throw wrapCloudFetchError(error, {
@@ -16980,6 +17076,13 @@ var OpensteerCloudClient = class {
     throw new Error(`Timed out waiting for cloud session ${sessionId} to close.`);
   }
 };
+function createRequestSignal(options) {
+  const timeoutSignal = AbortSignal.timeout(options.timeoutMs ?? 3e4);
+  if (options.signal === void 0) {
+    return timeoutSignal;
+  }
+  return AbortSignal.any([options.signal, timeoutSignal]);
+}
 function delay(ms) {
   return new Promise((resolve4) => {
     setTimeout(resolve4, ms);
@@ -17030,7 +17133,7 @@ function resolveCloudConfig(input = {}) {
 
 // ../runtime-core/package.json
 var package_default = {
-  version: "0.1.7"};
+  version: "0.2.0"};
 
 // ../runtime-core/src/version.ts
 var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
@@ -20848,6 +20951,9 @@ var MUTATION_CAPTURE_FINALIZE_TIMEOUT_MS = 5e3;
 var PERSISTED_NETWORK_FLUSH_TIMEOUT_MS = 5e3;
 var PENDING_OPERATION_EVENT_CAPTURE_LIMIT = 64;
 var PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS = 1e3;
+var REPLAY_PROBE_MIN_ATTEMPT_TIMEOUT_MS = 3e3;
+var REPLAY_PROBE_MAX_ATTEMPT_TIMEOUT_MS = 15e3;
+var REPLAY_PROBE_POST_SUCCESS_ATTEMPT_TIMEOUT_MS = 5e3;
 var OpensteerSessionRuntime = class {
   workspace;
   rootPath;
@@ -21709,26 +21815,27 @@ var OpensteerSessionRuntime = class {
     }
   }
   async queryNetwork(input = {}, options = {}) {
-    assertValidSemanticOperationInput("network.query", input);
+    const normalizedInput = normalizeNetworkQueryInput(input);
+    assertValidSemanticOperationInput("network.query", normalizedInput);
     const root = await this.ensureRoot();
     const startedAt = Date.now();
     try {
       const output = await this.runWithOperationTimeout(
         "network.query",
         async (timeout) => {
-          await this.syncPersistedNetworkSelection(timeout, input, {
+          await this.syncPersistedNetworkSelection(timeout, normalizedInput, {
             includeBodies: false
           });
           const rawRecords = await timeout.runStep(
             () => root.registry.savedNetwork.query({
-              ...this.toSavedNetworkQueryInput(input),
-              limit: Math.max(input.limit ?? 50, 1e3)
+              ...this.toSavedNetworkQueryInput(normalizedInput),
+              limit: Math.max(normalizedInput.limit ?? 50, 1e3)
             })
           );
-          const filtered = filterNetworkSummaryRecords(rawRecords, input);
+          const filtered = filterNetworkSummaryRecords(rawRecords, normalizedInput);
           const sorted = sortPersistedNetworkRecordsChronologically(filtered);
-          const sliced = sliceNetworkSummaryWindow(sorted, input);
-          const limited = sliced.slice(0, Math.max(1, Math.min(input.limit ?? 50, 200)));
+          const sliced = sliceNetworkSummaryWindow(sorted, normalizedInput);
+          const limited = sliced.slice(0, Math.max(1, Math.min(normalizedInput.limit ?? 50, 200)));
           const summaries = await this.buildNetworkSummaryRecords(limited, timeout);
           return {
             records: summaries
@@ -21742,9 +21849,9 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "ok",
         data: {
-          limit: input.limit ?? 50,
-          ...input.capture === void 0 ? {} : { capture: input.capture },
-          ...input.json === true ? { json: true } : {},
+          limit: normalizedInput.limit ?? 50,
+          ...normalizedInput.capture === void 0 ? {} : { capture: normalizedInput.capture },
+          ...normalizedInput.json === true ? { json: true } : {},
           count: output.records.length
         },
         context: buildRuntimeTraceContext({
@@ -21769,12 +21876,13 @@ var OpensteerSessionRuntime = class {
     }
   }
   async getNetworkDetail(input, options = {}) {
+    const normalizedRecordId = normalizeNetworkRecordId(input.recordId);
     const startedAt = Date.now();
     try {
       const output = await this.runWithOperationTimeout(
         "network.detail",
         async (timeout) => {
-          const record = await this.resolveNetworkRecordByRecordId(input.recordId, timeout, {
+          const record = await this.resolveNetworkRecordByRecordId(normalizedRecordId, timeout, {
             includeBodies: true,
             redactSecretHeaders: false
           });
@@ -21793,8 +21901,8 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "ok",
         data: {
-          recordId: input.recordId,
-          status: output.summary.status,
+          recordId: normalizedRecordId,
+          ...output.summary.status === void 0 ? {} : { status: output.summary.status },
           url: output.summary.url
         },
         context: buildRuntimeTraceContext({
@@ -23198,7 +23306,9 @@ var OpensteerSessionRuntime = class {
       ...graphql.persisted === void 0 ? {} : { persisted: graphql.persisted },
       ...graphqlVariables === void 0 ? {} : { variables: graphqlVariables }
     };
-    const requestBody = shouldShowRequestBody(record.record.method) && record.record.requestBody !== void 0 ? buildStructuredBodyPreview(record.record.requestBody, record.record.requestHeaders) : void 0;
+    const requestBody = shouldShowRequestBody(record.record.method) && record.record.requestBody !== void 0 ? buildStructuredBodyPreview(record.record.requestBody, record.record.requestHeaders, {
+      truncateData: false
+    }) : void 0;
     const responseBody = record.record.responseBody === void 0 ? void 0 : buildStructuredBodyPreview(record.record.responseBody, record.record.responseHeaders);
     const notes = detectNetworkRecordNotes(record);
     return {
@@ -23228,8 +23338,18 @@ var OpensteerSessionRuntime = class {
     let recommended;
     for (const transport of REPLAY_TRANSPORT_LADDER) {
       const attemptStartedAt = Date.now();
+      const attemptTimeoutMs = resolveReplayProbeAttemptTimeoutMs({
+        remainingMs: timeout.remainingMs(),
+        transportsRemaining: REPLAY_TRANSPORT_LADDER.length - attempts.length,
+        recommendedFound: recommended !== void 0
+      });
       try {
-        const output = await this.executeReplayTransportAttempt(transport, request, timeout);
+        const output = await this.executeReplayTransportAttemptWithinBudget(
+          transport,
+          request,
+          timeout,
+          attemptTimeoutMs
+        );
         const ok = matchesSuccessFingerprintFromProtocolResponse(output.response, fingerprint);
         attempts.push({
           transport,
@@ -23245,7 +23365,7 @@ var OpensteerSessionRuntime = class {
           transport,
           ok: false,
           durationMs: Date.now() - attemptStartedAt,
-          error: normalizeRuntimeErrorMessage(error)
+          error: normalizeProbeTransportAttemptError(transport, error, attemptTimeoutMs)
         });
       }
     }
@@ -23449,6 +23569,23 @@ var OpensteerSessionRuntime = class {
       }
     }
   }
+  async executeReplayTransportAttemptWithinBudget(transport, request, timeout, attemptTimeoutMs) {
+    if (attemptTimeoutMs === void 0) {
+      return this.executeReplayTransportAttempt(transport, request, timeout);
+    }
+    return runWithPolicyTimeout(
+      {
+        resolveTimeoutMs() {
+          return attemptTimeoutMs;
+        }
+      },
+      {
+        operation: timeout.operation,
+        signal: timeout.signal
+      },
+      (attemptTimeout) => this.executeReplayTransportAttempt(transport, request, attemptTimeout)
+    );
+  }
   async executeFetchTransportAttempt(transport, request, timeout, input) {
     let prepared = finalizeMaterializedTransportRequest(request, transport);
     if (input.cookies !== false && transport === "direct-http" && this.currentBinding() !== void 0) {
@@ -24363,10 +24500,15 @@ var OpensteerSessionRuntime = class {
     return this.observationSessionId ?? this.sessionRef;
   }
   runWithOperationTimeout(operation, callback, options = {}) {
+    const timeoutPolicy = options.timeoutMs === void 0 ? this.policy.timeout : {
+      resolveTimeoutMs() {
+        return options.timeoutMs;
+      }
+    };
     const existingCollector = this.operationEventStorage.getStore();
     if (existingCollector !== void 0) {
       return runWithPolicyTimeout(
-        this.policy.timeout,
+        timeoutPolicy,
         {
           operation,
           ...options.signal === void 0 ? {} : { signal: options.signal }
@@ -24379,7 +24521,7 @@ var OpensteerSessionRuntime = class {
     return this.operationEventStorage.run(collector, async () => {
       try {
         return await runWithPolicyTimeout(
-          this.policy.timeout,
+          timeoutPolicy,
           {
             operation,
             ...options.signal === void 0 ? {} : { signal: options.signal }
@@ -24549,6 +24691,21 @@ function buildEngineNetworkRecordFilters(input) {
 function normalizeNetworkStatusFilter(status) {
   return String(status);
 }
+function normalizeNetworkQueryInput(input) {
+  return {
+    ...input,
+    ...input.recordId === void 0 ? {} : { recordId: normalizeNetworkRecordId(input.recordId) },
+    ...input.before === void 0 ? {} : { before: normalizeNetworkRecordId(input.before) },
+    ...input.after === void 0 ? {} : { after: normalizeNetworkRecordId(input.after) }
+  };
+}
+function normalizeNetworkRecordId(recordId) {
+  const trimmed = recordId.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("record:")) {
+    return trimmed;
+  }
+  return `record:${trimmed}`;
+}
 function resolveLiveQueryRequestIds(input, history) {
   const requestIdCandidates = [];
   if (input.recordId !== void 0) {
@@ -24761,6 +24918,20 @@ var REPLAY_TRANSPORT_LADDER = [
   "context-http",
   "page-http"
 ];
+function resolveReplayProbeAttemptTimeoutMs(input) {
+  const attemptCapMs = input.recommendedFound ? REPLAY_PROBE_POST_SUCCESS_ATTEMPT_TIMEOUT_MS : REPLAY_PROBE_MAX_ATTEMPT_TIMEOUT_MS;
+  const clampedRemaining = input.remainingMs === void 0 ? void 0 : Math.max(0, input.remainingMs);
+  if (clampedRemaining === 0) {
+    return 0;
+  }
+  if (clampedRemaining === void 0) {
+    return attemptCapMs;
+  }
+  const sliceMs = Math.floor(clampedRemaining / Math.max(1, input.transportsRemaining));
+  const minimumBudgetAffordable = clampedRemaining >= REPLAY_PROBE_MIN_ATTEMPT_TIMEOUT_MS * input.transportsRemaining;
+  const attemptBudgetMs = minimumBudgetAffordable ? Math.max(REPLAY_PROBE_MIN_ATTEMPT_TIMEOUT_MS, sliceMs) : sliceMs;
+  return Math.min(clampedRemaining, attemptCapMs, Math.max(1, attemptBudgetMs));
+}
 function filterNetworkSummaryRecords(records, input) {
   return records.filter((record) => {
     if (record.record.resourceType === "preflight" || record.record.method === "OPTIONS") {
@@ -24933,10 +25104,10 @@ function extractGraphqlOperationName(queryText) {
 function shouldShowRequestBody(method) {
   return !["GET", "HEAD", "DELETE", "OPTIONS"].includes(method.trim().toUpperCase());
 }
-function buildStructuredBodyPreview(body, headers) {
+function buildStructuredBodyPreview(body, headers, options = {}) {
   const contentType = headerValue(headers, "content-type") ?? body?.mimeType;
   const parsed = parseStructuredPayload(body, contentType);
-  const data = parsed === void 0 ? void 0 : typeof parsed === "string" ? truncateInlineText(parsed) : truncateStructuredValue(parsed);
+  const data = parsed === void 0 ? void 0 : options.truncateData === false ? parsed : typeof parsed === "string" ? truncateInlineText(parsed) : truncateStructuredValue(parsed);
   return {
     bytes: body?.originalByteLength ?? body?.capturedByteLength ?? 0,
     ...contentType === void 0 ? {} : { contentType },
@@ -25149,10 +25320,12 @@ function resolveSessionFetchTransportLadder(transport) {
       return ["direct-http"];
     case "matched-tls":
       return ["matched-tls"];
+    case "context":
+      return ["context-http"];
     case "page":
       return ["page-http"];
     case "auto":
-      return ["direct-http", "matched-tls", "page-http"];
+      return ["direct-http", "matched-tls", "context-http", "page-http"];
   }
 }
 function detectChallengeNoteFromRecord(record) {
@@ -25297,6 +25470,12 @@ function diffStorageSnapshot(left, right) {
 function normalizeRuntimeErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function normalizeProbeTransportAttemptError(transport, error, attemptTimeoutMs) {
+  if (attemptTimeoutMs !== void 0 && error instanceof OpensteerProtocolError && error.code === "timeout") {
+    return `${transport} probe exceeded ${String(attemptTimeoutMs)}ms`;
+  }
+  return normalizeRuntimeErrorMessage(error);
+}
 function applyBrowserCookiesToTransportRequest(request, cookies) {
   if (cookies.length === 0) {
     return request;
@@ -26064,10 +26243,10 @@ var OpensteerSemanticRestClient = class {
   constructor(connection) {
     this.connection = connection;
   }
-  async invoke(operation, input) {
-    return this.invokeInternal(operation, input, false);
+  async invoke(operation, input, options = {}) {
+    return this.invokeInternal(operation, input, false, options);
   }
-  async invokeInternal(operation, input, hasRetried) {
+  async invokeInternal(operation, input, hasRetried, options) {
     const endpoint = opensteerSemanticRestEndpoints.find((entry) => entry.name === operation);
     if (!endpoint) {
       throw new Error(`unsupported semantic operation ${operation}`);
@@ -26081,10 +26260,11 @@ var OpensteerSemanticRestClient = class {
         method: "POST",
         headers: {
           authorization: await this.connection.getAuthorizationHeader(),
-          "content-type": "application/json; charset=utf-8"
+          "content-type": "application/json; charset=utf-8",
+          ...options.timeoutMs === void 0 ? {} : { "x-opensteer-timeout-ms": String(options.timeoutMs) }
         },
         body: JSON.stringify(request),
-        signal: AbortSignal.timeout(3e4)
+        signal: createRequestSignal2(options)
       });
     } catch (error) {
       if (operation === "session.close" && isFetchFailure(error)) {
@@ -26100,7 +26280,7 @@ var OpensteerSemanticRestClient = class {
       return envelope.data;
     } catch (error) {
       if (!hasRetried && this.connection.handleError && await this.connection.handleError(error, { operation })) {
-        return this.invokeInternal(operation, input, true);
+        return this.invokeInternal(operation, input, true, options);
       }
       if (operation === "session.close" && isFetchFailure(error)) {
         return { closed: true };
@@ -26112,6 +26292,13 @@ var OpensteerSemanticRestClient = class {
     return this.invoke("session.close", {});
   }
 };
+function createRequestSignal2(options) {
+  const timeoutSignal = AbortSignal.timeout(options.timeoutMs ?? 3e4);
+  if (options.signal === void 0) {
+    return timeoutSignal;
+  }
+  return AbortSignal.any([options.signal, timeoutSignal]);
+}
 function isFetchFailure(error) {
   if (!(error instanceof Error)) {
     return false;
@@ -26478,13 +26665,44 @@ function asRecord(value) {
   return value;
 }
 
-// src/cloud/registry-sync.ts
-var REGISTRY_SYNC_MAX_PAYLOAD_BYTES = 15e5;
-var REGISTRY_SYNC_MAX_ENTRIES_PER_BATCH = 100;
-async function syncLocalRegistryToCloud(client, workspace, store) {
+// src/cloud/workspace-sync.ts
+var WORKSPACE_SYNC_MAX_PAYLOAD_BYTES = 15e5;
+var WORKSPACE_SYNC_MAX_ENTRIES_PER_BATCH = 100;
+async function syncLocalWorkspaceToCloud(client, workspace, store) {
+  await syncDescriptorRegistryToCloud(client, workspace, store);
+  await syncRequestPlansToCloud(client, workspace, store);
+}
+async function syncDescriptorRegistryToCloud(client, workspace, store) {
   const descriptors = await store.registry.descriptors.list();
-  const descriptorEntries = descriptors.map((record) => toDescriptorImportEntry(workspace, record));
-  await importInBatches(descriptorEntries, (entries) => client.importDescriptors(entries));
+  const entries = descriptors.map((record) => toDescriptorImportEntry(workspace, record));
+  await importInBatches(entries, {
+    getPayloadByteLength: (batch) => payloadByteLength({ entries: batch }),
+    importBatch: (batch) => client.importDescriptors(batch)
+  });
+}
+async function syncRequestPlansToCloud(client, workspace, store) {
+  const requestPlans = await store.registry.requestPlans.list();
+  const entries = requestPlans.map((record) => toRequestPlanImportEntry(workspace, record)).filter((entry) => entry !== void 0);
+  await importInBatches(entries, {
+    getPayloadByteLength: (batch) => payloadByteLength({ entries: batch }),
+    importBatch: (batch) => client.importRequestPlans({ entries: batch })
+  });
+}
+function toRequestPlanImportEntry(workspace, record) {
+  const entry = {
+    workspace,
+    recordId: record.id,
+    key: record.key,
+    version: record.version,
+    contentHash: record.contentHash,
+    tags: [...record.tags],
+    ...record.provenance === void 0 ? {} : { provenance: record.provenance },
+    ...record.freshness === void 0 ? {} : { freshness: record.freshness },
+    payload: record.payload,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  };
+  return payloadByteLength({ entries: [entry] }) <= WORKSPACE_SYNC_MAX_PAYLOAD_BYTES ? entry : void 0;
 }
 function toDescriptorImportEntry(workspace, record) {
   return {
@@ -26500,19 +26718,19 @@ function toDescriptorImportEntry(workspace, record) {
     updatedAt: record.updatedAt
   };
 }
-async function importInBatches(entries, importBatch) {
+async function importInBatches(entries, options) {
   if (entries.length === 0) {
     return;
   }
-  for (const batch of chunkEntries(entries)) {
-    await importBatch(batch);
+  for (const batch of chunkEntries(entries, options.getPayloadByteLength)) {
+    await options.importBatch(batch);
   }
 }
-function chunkEntries(entries) {
+function chunkEntries(entries, getPayloadByteLength) {
   const batches = [];
   let currentBatch = [];
   for (const entry of entries) {
-    if (payloadByteLength([entry]) > REGISTRY_SYNC_MAX_PAYLOAD_BYTES) {
+    if (getPayloadByteLength([entry]) > WORKSPACE_SYNC_MAX_PAYLOAD_BYTES) {
       continue;
     }
     if (currentBatch.length === 0) {
@@ -26520,7 +26738,7 @@ function chunkEntries(entries) {
       continue;
     }
     const nextBatch = [...currentBatch, entry];
-    if (nextBatch.length > REGISTRY_SYNC_MAX_ENTRIES_PER_BATCH || payloadByteLength(nextBatch) > REGISTRY_SYNC_MAX_PAYLOAD_BYTES) {
+    if (nextBatch.length > WORKSPACE_SYNC_MAX_ENTRIES_PER_BATCH || getPayloadByteLength(nextBatch) > WORKSPACE_SYNC_MAX_PAYLOAD_BYTES) {
       batches.push(currentBatch);
       currentBatch = [entry];
       continue;
@@ -26532,8 +26750,8 @@ function chunkEntries(entries) {
   }
   return batches;
 }
-function payloadByteLength(entries) {
-  return Buffer.byteLength(JSON.stringify({ entries }), "utf8");
+function payloadByteLength(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
 }
 
 // src/cloud/session-proxy.ts
@@ -26544,14 +26762,17 @@ var CloudSessionProxy = class {
   cleanupRootOnClose;
   cloud;
   observability;
+  policy;
   sessionId;
   semanticGrant;
   client;
   automation;
   workspaceStore;
+  syncWorkspaceOnClose = false;
   constructor(cloud, options = {}) {
     this.cloud = cloud;
     this.workspace = options.workspace;
+    this.policy = options.policy ?? defaultPolicy();
     this.observability = options.observability;
     this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7__default.default.join(os.tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
       rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
@@ -26560,14 +26781,17 @@ var CloudSessionProxy = class {
     this.cleanupRootOnClose = options.cleanupRootOnClose ?? this.workspace === void 0;
   }
   async open(input = {}) {
-    await this.ensureSession({
-      ...input.browser === void 0 ? {} : { browser: input.browser },
-      ...input.launch === void 0 ? {} : { launch: input.launch },
-      ...input.context === void 0 ? {} : { context: input.context }
-    });
-    return this.requireClient().invoke("session.open", {
-      ...input.url === void 0 ? {} : { url: input.url }
-    });
+    return this.invokeSemanticOperation(
+      "session.open",
+      {
+        ...input.url === void 0 ? {} : { url: input.url }
+      },
+      {
+        ...input.browser === void 0 ? {} : { browser: input.browser },
+        ...input.launch === void 0 ? {} : { launch: input.launch },
+        ...input.context === void 0 ? {} : { context: input.context }
+      }
+    );
   }
   async info() {
     const persisted = this.client !== void 0 || this.sessionId !== void 0 ? void 0 : await this.loadPersistedSession();
@@ -26610,108 +26834,88 @@ var CloudSessionProxy = class {
     };
   }
   async listPages(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.list", input);
+    return this.invokeSemanticOperation("page.list", input);
   }
   async newPage(input = {}) {
-    await this.ensureSession();
-    return this.requireAutomation().invoke("page.new", input);
+    return this.invokeAutomationOperation(
+      "page.new",
+      (automation) => automation.invoke("page.new", input)
+    );
   }
   async activatePage(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.activate", input);
+    return this.invokeSemanticOperation("page.activate", input);
   }
   async closePage(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.close", input);
+    return this.invokeSemanticOperation("page.close", input);
   }
   async goto(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.goto", input);
+    return this.invokeSemanticOperation("page.goto", input);
   }
   async evaluate(input) {
-    await this.ensureSession();
-    return this.requireAutomation().invoke("page.evaluate", input);
+    return this.invokeAutomationOperation(
+      "page.evaluate",
+      (automation) => automation.invoke("page.evaluate", input)
+    );
   }
   async addInitScript(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.add-init-script", input);
+    return this.invokeSemanticOperation("page.add-init-script", input);
   }
   async snapshot(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("page.snapshot", input);
+    return this.invokeSemanticOperation("page.snapshot", input);
   }
   async click(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.click", input);
+    return this.invokeSemanticOperation("dom.click", input);
   }
   async hover(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.hover", input);
+    return this.invokeSemanticOperation("dom.hover", input);
   }
   async input(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.input", input);
+    return this.invokeSemanticOperation("dom.input", input);
   }
   async scroll(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.scroll", input);
+    return this.invokeSemanticOperation("dom.scroll", input);
   }
   async extract(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("dom.extract", input);
+    return this.invokeSemanticOperation("dom.extract", input);
   }
   async queryNetwork(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("network.query", input);
+    return this.invokeSemanticOperation("network.query", input);
   }
   async getNetworkDetail(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("network.detail", input);
+    return this.invokeSemanticOperation("network.detail", input);
   }
   async captureInteraction(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("interaction.capture", input);
+    return this.invokeSemanticOperation("interaction.capture", input);
   }
   async getInteraction(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("interaction.get", input);
+    return this.invokeSemanticOperation("interaction.get", input);
   }
   async diffInteraction(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("interaction.diff", input);
+    return this.invokeSemanticOperation("interaction.diff", input);
   }
   async replayInteraction(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("interaction.replay", input);
+    return this.invokeSemanticOperation("interaction.replay", input);
   }
   async captureScripts(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("scripts.capture", input);
+    return this.invokeSemanticOperation("scripts.capture", input);
   }
   async readArtifact(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("artifact.read", input);
+    return this.invokeSemanticOperation("artifact.read", input);
   }
   async beautifyScript(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("scripts.beautify", input);
+    return this.invokeSemanticOperation("scripts.beautify", input);
   }
   async deobfuscateScript(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("scripts.deobfuscate", input);
+    return this.invokeSemanticOperation("scripts.deobfuscate", input);
   }
   async sandboxScript(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("scripts.sandbox", input);
+    return this.invokeSemanticOperation("scripts.sandbox", input);
   }
   async solveCaptcha(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("captcha.solve", input);
+    return this.invokeSemanticOperation("captcha.solve", input);
   }
   async getCookies(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("session.cookies", input);
+    return this.invokeSemanticOperation("session.cookies", input);
   }
   async route(input) {
     await this.ensureSession();
@@ -26722,20 +26926,16 @@ var CloudSessionProxy = class {
     return this.requireAutomation().interceptScript(input);
   }
   async getStorageSnapshot(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("session.storage", input);
+    return this.invokeSemanticOperation("session.storage", input);
   }
   async getBrowserState(input = {}) {
-    await this.ensureSession();
-    return this.requireClient().invoke("session.state", input);
+    return this.invokeSemanticOperation("session.state", input);
   }
   async fetch(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("session.fetch", input);
+    return this.invokeSemanticOperation("session.fetch", input);
   }
   async computerExecute(input) {
-    await this.ensureSession();
-    return this.requireClient().invoke("computer.execute", input);
+    return this.invokeSemanticOperation("computer.execute", input);
   }
   async close() {
     const session = await this.loadPersistedSession() ?? (this.sessionId === void 0 ? void 0 : {
@@ -26747,6 +26947,14 @@ var CloudSessionProxy = class {
       startedAt: Date.now(),
       updatedAt: Date.now()
     });
+    let syncError;
+    if (this.syncWorkspaceOnClose) {
+      try {
+        await this.syncWorkspaceToCloud();
+      } catch (error) {
+        syncError = error;
+      }
+    }
     try {
       if (session !== void 0) {
         await this.cloud.closeSession(session.sessionId).catch((error) => {
@@ -26767,6 +26975,9 @@ var CloudSessionProxy = class {
         await promises.rm(this.rootPath, { recursive: true, force: true }).catch(() => void 0);
       }
     }
+    if (syncError !== void 0) {
+      throw syncError;
+    }
     return { closed: true };
   }
   async disconnect() {
@@ -26774,34 +26985,38 @@ var CloudSessionProxy = class {
       await this.close();
       return;
     }
+    let syncError;
+    if (this.syncWorkspaceOnClose) {
+      try {
+        await this.syncWorkspaceToCloud();
+      } catch (error) {
+        syncError = error;
+      }
+    }
     this.client = void 0;
     await this.automation?.close().catch(() => void 0);
     this.automation = void 0;
     this.sessionId = void 0;
     this.semanticGrant = void 0;
+    if (syncError !== void 0) {
+      throw syncError;
+    }
   }
-  async ensureSession(input = {}) {
+  async ensureSession(input = {}, timeout) {
     if (this.client) {
       return;
     }
     assertSupportedCloudBrowserMode(input.browser);
     const localCloud = this.shouldUseLocalCloudTransport();
+    this.syncWorkspaceOnClose = localCloud && this.workspace !== void 0;
     const browserProfile = resolveCloudBrowserProfile(this.cloud, input);
     const persisted = await this.loadPersistedSession();
-    if (persisted !== void 0 && await this.isReusableCloudSession(persisted.sessionId)) {
-      if (localCloud) {
-        void this.syncRegistryToCloud();
-      } else {
-        await this.syncRegistryToCloud();
-      }
+    if (persisted !== void 0 && await this.isReusableCloudSession(persisted.sessionId, timeout)) {
+      await this.syncWorkspaceToCloud();
       this.bindClient(persisted);
       return;
     }
-    if (localCloud) {
-      void this.syncRegistryToCloud();
-    } else {
-      await this.syncRegistryToCloud();
-    }
+    await this.syncWorkspaceToCloud();
     const baseCreateInput = {
       ...this.workspace === void 0 ? {} : { name: this.workspace },
       ...input.launch === void 0 ? {} : { browser: input.launch },
@@ -26813,10 +27028,12 @@ var CloudSessionProxy = class {
       ...baseCreateInput,
       sourceType: "local-cloud",
       sourceRef: this.workspace,
-      localWorkspaceRootPath: this.rootPath,
-      locality: "auto"
+      localWorkspaceRootPath: this.rootPath
     } : baseCreateInput;
-    const session = await this.cloud.createSession(createInput);
+    const session = await this.cloud.createSession(createInput, {
+      signal: timeout?.signal,
+      timeoutMs: timeout?.remainingMs()
+    });
     const record = {
       layout: "opensteer-session",
       version: 1,
@@ -26829,15 +27046,12 @@ var CloudSessionProxy = class {
     await this.writePersistedSession(record);
     this.bindClient(record, session.initialGrants?.semantic);
   }
-  async syncRegistryToCloud() {
+  async syncWorkspaceToCloud() {
     if (this.workspace === void 0) {
       return;
     }
-    try {
-      const workspaceStore = await this.ensureWorkspaceStore();
-      await syncLocalRegistryToCloud(this.cloud, this.workspace, workspaceStore);
-    } catch {
-    }
+    const workspaceStore = await this.ensureWorkspaceStore();
+    await syncLocalWorkspaceToCloud(this.cloud, this.workspace, workspaceStore);
   }
   bindClient(record, initialSemanticGrant) {
     this.sessionId = record.sessionId;
@@ -26871,9 +27085,12 @@ var CloudSessionProxy = class {
   async clearPersistedSession() {
     await clearPersistedSessionRecord(this.rootPath, "cloud").catch(() => void 0);
   }
-  async isReusableCloudSession(sessionId) {
+  async isReusableCloudSession(sessionId, timeout) {
     try {
-      const session = await this.cloud.getSession(sessionId);
+      const session = await this.cloud.getSession(sessionId, {
+        signal: timeout?.signal,
+        timeoutMs: timeout?.remainingMs()
+      });
       return session.status !== "closed" && session.status !== "failed";
     } catch (error) {
       if (isMissingCloudSessionError(error)) {
@@ -26894,14 +27111,17 @@ var CloudSessionProxy = class {
     }
     return this.automation;
   }
-  async ensureSemanticGrant(forceRefresh = false) {
+  async ensureSemanticGrant(forceRefresh = false, timeout) {
     if (!forceRefresh && this.semanticGrant?.kind === "semantic" && this.semanticGrant.expiresAt > Date.now() + 1e4) {
       return this.semanticGrant;
     }
     if (!this.sessionId) {
       throw new Error("Cloud session has not been initialized.");
     }
-    const issued = await this.cloud.issueAccess(this.sessionId, ["semantic"]);
+    const issued = await this.cloud.issueAccess(this.sessionId, ["semantic"], {
+      signal: timeout?.signal,
+      timeoutMs: timeout?.remainingMs()
+    });
     const grant = issued.grants.semantic;
     if (!grant || grant.transport !== "http") {
       throw new Error("cloud did not issue a valid semantic grant");
@@ -26924,6 +27144,25 @@ var CloudSessionProxy = class {
       return false;
     }
   }
+  async invokeSemanticOperation(operation, input, sessionInit = {}) {
+    return this.runOperationWithPolicy(operation, async (timeout) => {
+      await this.ensureSession(sessionInit, timeout);
+      await this.ensureSemanticGrant(false, timeout);
+      return this.requireClient().invoke(operation, input, {
+        signal: timeout.signal,
+        timeoutMs: timeout.remainingMs()
+      });
+    });
+  }
+  async invokeAutomationOperation(operation, invoke, sessionInit = {}) {
+    return this.runOperationWithPolicy(operation, async (timeout) => {
+      await this.ensureSession(sessionInit, timeout);
+      return invoke(this.requireAutomation());
+    });
+  }
+  async runOperationWithPolicy(operation, invoke) {
+    return runWithPolicyTimeout(this.policy.timeout, { operation }, invoke);
+  }
   shouldUseLocalCloudTransport() {
     if (this.workspace === void 0) {
       return false;
@@ -27098,6 +27337,7 @@ function createOpensteerSemanticRuntime(input = {}) {
       ...runtimeOptions.rootDir === void 0 ? {} : { rootDir: runtimeOptions.rootDir },
       ...runtimeOptions.rootPath === void 0 ? {} : { rootPath: runtimeOptions.rootPath },
       ...runtimeOptions.workspace === void 0 ? {} : { workspace: runtimeOptions.workspace },
+      ...runtimeOptions.policy === void 0 ? {} : { policy: runtimeOptions.policy },
       ...runtimeOptions.cleanupRootOnClose === void 0 ? {} : { cleanupRootOnClose: runtimeOptions.cleanupRootOnClose },
       ...runtimeOptions.observability === void 0 ? {} : { observability: runtimeOptions.observability }
     });