humanish 0.136.0 → 0.137.0

package/dist/run/live-items.d.ts

@@ -13,11 +13,29 @@ export interface LiveItemsCursor {
     items: number;
     bytes: number;
 }
+/** How run.json binds a file of JSON lines: its byte count, its sha256 and its number of lines. */
+export interface JsonLinesIndex {
+    path: string;
+    bytes: number;
+    sha256: string;
+    lines: number;
+}
+/** What a refusal calls one line of a file and several: `an item` and `items` for a live file. */
+export interface LineNoun {
+    one: string;
+    many: string;
+}
 /**
- * The items the indexed prefix of a live file holds, or why the bytes do not match the index:
+ * The JSON object on each line of a file run.json binds, or why the bytes do not match the index:
  * `bytes` must be exactly the indexed byte count, hash to the indexed sha256, and hold the indexed
- * number of lines, each a JSON object.
+ * number of lines, each a JSON object. A refusal names the file and counts, never what it holds.
  */
+export declare function boundJsonLines(bytes: Buffer, index: JsonLinesIndex, noun: LineNoun): {
+    lines: Record<string, unknown>[];
+} | {
+    refused: string;
+};
+/** The items the indexed prefix of a live file holds, or why the bytes do not match the index. */
 export declare function liveItemsFromBytes(bytes: Buffer, index: LiveItemsIndex): {
     items: ActorTraceItem[];
 } | {

package/dist/run/live-items.js

@@ -29,19 +29,24 @@ export function isLiveItemsIndex(value) {
         typeof value.sha256 === "string" &&
         /^[0-9a-f]{64}$/.test(value.sha256));
 }
+const ITEM = { one: "an item", many: "items" };
 /**
- * The items the indexed prefix of a live file holds, or why the bytes do not match the index:
+ * The JSON object on each line of a file run.json binds, or why the bytes do not match the index:
  * `bytes` must be exactly the indexed byte count, hash to the indexed sha256, and hold the indexed
- * number of lines, each a JSON object.
+ * number of lines, each a JSON object. A refusal names the file and counts, never what it holds.
  */
-export function liveItemsFromBytes(bytes, index) {
+export function boundJsonLines(bytes, index, noun) {
     if (bytes.length !== index.bytes)
         return {
             refused: `${index.path} holds ${bytes.length} bytes and run.json records ${index.bytes}`,
         };
     if (createHash("sha256").update(bytes).digest("hex") !== index.sha256)
         return { refused: `${index.path} does not match the sha256 run.json records for it` };
-    return itemLinesOf(bytes, index.items, index.path);
+    return objectLinesOf(bytes, index.lines, index.path, noun);
+}
+/** The items the indexed prefix of a live file holds, or why the bytes do not match the index. */
+export function liveItemsFromBytes(bytes, index) {
+    return asItems(boundJsonLines(bytes, { ...index, lines: index.items }, ITEM));
 }
 /**
  * The items past `after` in the indexed prefix of a live file, from the file's bytes between
@@ -59,10 +64,14 @@ export function liveItemsAfter(bytes, index, after) {
         };
     if (bytes[0] !== 0x0a)
         return { refused: `${index.path} has no line end before byte ${after.bytes}` };
-    return itemLinesOf(bytes.subarray(1), index.items - after.items, index.path);
+    return asItems(objectLinesOf(bytes.subarray(1), index.items - after.items, index.path, ITEM));
+}
+/** A live file's lines as trace items. */
+function asItems(read) {
+    return "refused" in read ? read : { items: read.lines };
 }
 /** The JSON object on each of `count` lines in `bytes`, which must be UTF-8 and end a line. */
-function itemLinesOf(bytes, count, file) {
+function objectLinesOf(bytes, count, file, noun) {
     let text;
     try {
         text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
@@ -74,21 +83,21 @@ function itemLinesOf(bytes, count, file) {
     if (lines.length > 0 && lines.pop() !== "")
         return { refused: `${file} does not end its indexed bytes at a line end` };
     if (lines.length !== count)
-        return { refused: `${file} holds ${lines.length} items and run.json records ${count}` };
-    const items = [];
+        return { refused: `${file} holds ${lines.length} ${noun.many} and run.json records ${count}` };
+    const objects = [];
     for (const line of lines) {
-        let item;
+        let value;
         try {
-            item = JSON.parse(line);
+            value = JSON.parse(line);
         }
         catch {
             return { refused: `${file} holds a line that is not JSON` };
         }
-        if (!isRecord(item))
-            return { refused: `${file} holds a line that is not an item` };
-        items.push(item);
+        if (!isRecord(value))
+            return { refused: `${file} holds a line that is not ${noun.one}` };
+        objects.push(value);
     }
-    return { items };
+    return { lines: objects };
 }
 /** The warning for a participant whose live items were written in full on two writes in a row. */
 function rewrittenEvent(stream, position) {

package/dist/run/streams.d.ts

@@ -1,5 +1,6 @@
 import type { CodexAppServerTrace } from "../actors/codex/app-server-trace.js";
 import type { ActorStatus, ActorTrace, ActorTraceItem } from "../actors/contract.js";
+import type { BrowserNetworkIndex } from "../evidence/browser-network.js";
 import type { RunDesktopRecording } from "../evidence/desktop-recording-types.js";
 export type RunStreamKind = "ui" | "browser" | "terminal" | "tui" | "codex-ui" | "artifact" | "summary";
 export type RunSimulationStatus = "queued" | "preparing" | "running" | "passed" | "abandoned" | "incomplete" | "complete" | "blocked" | "timed_out" | "failed" | "contract_proof_only";
@@ -310,6 +311,12 @@ export interface RunStream {
     };
     completion?: RunStreamCompletion;
     recording?: RunDesktopRecording;
+    /**
+     * The participant's browser network log, when its study set `execution.network`: where the
+     * file is, what binds it, and why records are missing. The shape guard does not read it; verify
+     * checks it with the file (src/verify/network.ts).
+     */
+    network?: BrowserNetworkIndex;
     artifacts: Array<{
         label: string;
         path: string;

package/dist/study/config.js

@@ -39,7 +39,7 @@ import { invalid, optionalStr, str } from "./parse/values.js";
 import { isComputerUseComposition, routeOf } from "./routing.js";
 import { declaredParticipantIds } from "./plan-participants.js";
 import { ID_PATTERN, STUDY_SCHEMA, } from "./types.js";
-import { automaticAnalysisRouteReason, desktopMediaValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, smtpValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "./validation.js";
+import { automaticAnalysisRouteReason, desktopMediaValidationReason, networkCaptureValidationReason, outputTokenLimitValidationReason, receivingEmailValidationReason, smtpValidationReason, taskProtocolValidationReason, waitLimitValidationReason, } from "./validation.js";
 import { forwardDeclaredWarnings, inertFieldLabels, inertFieldPaths } from "./warnings.js";
 import { plural } from "../run/text.js";
 /**
@@ -228,6 +228,9 @@ function checkStudyConfig(config) {
     const mediaReason = desktopMediaValidationReason(config);
     if (mediaReason)
         return invalid(mediaReason);
+    const networkReason = networkCaptureValidationReason(config);
+    if (networkReason)
+        return invalid(networkReason);
     const outputLimitReason = outputTokenLimitValidationReason(config);
     if (outputLimitReason)
         return invalid(outputLimitReason);

package/dist/study/keys.d.ts

@@ -187,6 +187,9 @@ export declare const EXECUTION: {
         transport: true;
         doNotTrack: true;
     };
+    network: {
+        origins: true;
+    };
     desktop: {
         template: true;
         browser: true;

package/dist/study/keys.js

@@ -119,6 +119,8 @@ export const EXECUTION = {
     completionTimeoutMs: true,
     egressAllow: true,
     terminal: { stdin: true, transport: true, doNotTrack: true },
+    // true or false, or a mapping whose keys are checked here.
+    network: { origins: true },
     desktop: {
         template: true,
         browser: true,

package/dist/study/parse/comms.js

@@ -1,4 +1,4 @@
-import { invalid, posInt, str } from "./values.js";
+import { exactOrigin, invalid, posInt, str } from "./values.js";
 import { isRecord } from "../../run/type-guards.js";
 // Fail-loud (never silently swallow a comms setting): a malformed `comms` block returns a parse
 // failure rather than being dropped.
@@ -104,25 +104,6 @@ function parseEmailConnection(raw) {
     }
     return { ok: true, value };
 }
-/** The origin of an http(s) URL with no credentials, path, query or fragment, else undefined. */
-function exactOrigin(input) {
-    if (typeof input !== "string")
-        return undefined;
-    try {
-        const url = new URL(input);
-        return ["http:", "https:"].includes(url.protocol) &&
-            !url.username &&
-            !url.password &&
-            url.pathname === "/" &&
-            !url.search &&
-            !url.hash
-            ? url.origin
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** `comms.email.external`: the catch the adopter runs, its inbox and the env var holding its token. */
 function parseExternalCatch(raw) {
     if (raw === undefined)

package/dist/study/parse/execution.js

@@ -1,7 +1,7 @@
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { DEVICE_PRESET_NAMES, isDevicePresetName } from "../device-presets.js";
 import { isExactRuntimeVersion } from "../../routes/terminal/runtime.js";
-import { invalid, nonNegNumber, posInt, str } from "./values.js";
+import { exactOrigin, invalid, nonNegNumber, posInt, str } from "./values.js";
 import { isRecord } from "../../run/type-guards.js";
 import { scanEncodedText } from "../../evidence/encoded-text.js";
 export function parseExecution(raw) {
@@ -34,6 +34,11 @@ export function parseExecution(raw) {
     }
     if (desktopResult.value)
         execution.desktop = desktopResult.value;
+    const network = parseNetwork(raw.network);
+    if (!network.ok)
+        return network;
+    if (network.value !== undefined)
+        execution.network = network.value;
     const terminalResult = parseTerminal(raw.terminal);
     if (!terminalResult.ok) {
         return terminalResult;
@@ -71,6 +76,30 @@ export function parseExecution(raw) {
     }
     return { ok: true, value: Object.keys(execution).length > 0 ? execution : undefined };
 }
+/** `execution.network`: true, false, or `{ origins }`. False reads as absent. */
+function parseNetwork(raw) {
+    if (raw === undefined || raw === false)
+        return { ok: true, value: undefined };
+    if (raw === true)
+        return { ok: true, value: true };
+    if (!isRecord(raw))
+        return invalid("`execution.network` must be true, false, or a mapping with `origins`: the origins whose requests are kept beside the target's.");
+    if (raw.origins === undefined)
+        return { ok: true, value: {} };
+    if (!Array.isArray(raw.origins) || raw.origins.length > 16)
+        return invalid("`execution.network.origins` must list at most 16 exact http(s) origins, such as https://api.example.com.");
+    const origins = [];
+    for (const entry of raw.origins) {
+        const origin = exactOrigin(entry);
+        if (origin === undefined)
+            return invalid("`execution.network.origins` accepts exact http(s) origins without credentials, path, query or fragment, such as https://api.example.com.");
+        // The network log's index records each origin, so one verify would flag is refused here.
+        if (scanEncodedText(origin).sensitive)
+            return invalid("`execution.network.origins` has an origin that looks like a secret or a local path, and the run records each origin in its network log index. List the origin of the API or asset host only.");
+        origins.push(origin);
+    }
+    return { ok: true, value: { origins: [...new Set(origins)] } };
+}
 function parseTerminal(raw) {
     if (raw === undefined) {
         return { ok: true, value: undefined };

package/dist/study/parse/values.d.ts

@@ -14,3 +14,8 @@ export declare function posInt(value: unknown): number | undefined;
 /** A non-negative finite number (0 allowed; caps default to 0 = no-spend). Accepts a numeric
  *  string too, since YAML scalars can arrive as strings. */
 export declare function nonNegNumber(value: unknown): number | undefined;
+/**
+ * The origin of an http(s) URL with no credentials, path, query or fragment, else undefined. The
+ * origin lists `comms.email.allowedOrigins` and `execution.network.origins` take this rule.
+ */
+export declare function exactOrigin(input: unknown): string | undefined;

package/dist/study/parse/values.js

@@ -60,3 +60,25 @@ export function nonNegNumber(value) {
     }
     return undefined;
 }
+/**
+ * The origin of an http(s) URL with no credentials, path, query or fragment, else undefined. The
+ * origin lists `comms.email.allowedOrigins` and `execution.network.origins` take this rule.
+ */
+export function exactOrigin(input) {
+    if (typeof input !== "string")
+        return undefined;
+    try {
+        const url = new URL(input);
+        return ["http:", "https:"].includes(url.protocol) &&
+            !url.username &&
+            !url.password &&
+            url.pathname === "/" &&
+            !url.search &&
+            !url.hash
+            ? url.origin
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/study/plan-base.js

@@ -20,7 +20,9 @@ function residualOf(config) {
         ...(policies === undefined ? {} : { policies }),
         ...(defaults === undefined ? {} : { defaults }),
         ...(review === undefined ? {} : { review }),
-        ...(config.execution?.desktop === undefined && config.execution?.target === undefined
+        ...(config.execution?.desktop === undefined &&
+            config.execution?.target === undefined &&
+            config.execution?.network === undefined
             ? {}
             : {
                 execution: {
@@ -30,6 +32,9 @@ function residualOf(config) {
                     ...(config.execution?.target === undefined
                         ? {}
                         : { target: config.execution.target }),
+                    ...(config.execution?.network === undefined
+                        ? {}
+                        : { network: config.execution.network }),
                 },
             }),
         subject: {

package/dist/study/plan-types.d.ts

@@ -51,7 +51,7 @@ export type Requirement = {
  * fields at run time.
  */
 export type ResidualConfig = Pick<StudyConfig, "comms" | "policies" | "defaults" | "review"> & {
-    readonly execution?: Pick<NonNullable<StudyConfig["execution"]>, "desktop" | "target">;
+    readonly execution?: Pick<NonNullable<StudyConfig["execution"]>, "desktop" | "target" | "network">;
     readonly subject: Pick<StudyConfig["subject"], "clone" | "localTree" | "repos" | "envValues">;
 };
 export interface PlannedAnalysis {

package/dist/study/study-fields.d.ts

@@ -1,7 +1,13 @@
-import type { StudyConfig, StudyParticipantEntry } from "./types.js";
+import type { StudyConfig, StudyNetworkCapture, StudyParticipantEntry } from "./types.js";
 /** The participants listed one by one: a `participants` list. Undefined when none is listed. */
 export declare function participantList(config: StudyConfig): readonly StudyParticipantEntry[] | undefined;
 /** The declared number of identical participants: `participants: <n>` or `participants.count`. */
 export declare function declaredParticipantCount(config: StudyConfig): number | undefined;
 /** The steer each of a counted group of participants gets: `participants.instruction`. */
 export declare function participantInstruction(config: StudyConfig): string | undefined;
+/**
+ * The origins each participant's network log keeps beside its target's
+ * (`execution.network.origins`), or undefined when capture is off: `execution.network` absent or
+ * false.
+ */
+export declare function networkCaptureOrigins(network: StudyNetworkCapture | undefined): readonly string[] | undefined;

package/dist/study/study-fields.js

@@ -17,6 +17,16 @@ export function declaredParticipantCount(config) {
 export function participantInstruction(config) {
     return isGroup(config.participants) ? config.participants.instruction : undefined;
 }
+/**
+ * The origins each participant's network log keeps beside its target's
+ * (`execution.network.origins`), or undefined when capture is off: `execution.network` absent or
+ * false.
+ */
+export function networkCaptureOrigins(network) {
+    if (network === undefined || network === false)
+        return undefined;
+    return network === true ? [] : (network.origins ?? []);
+}
 function isGroup(participants) {
     return typeof participants === "object" && participants !== null && !Array.isArray(participants);
 }

package/dist/study/types.d.ts

@@ -570,6 +570,15 @@ export interface StudyDesktopFidelity {
     /** Full user-agent string to present; default: a mobile Safari string. */
     userAgent?: string;
 }
+/**
+ * `execution.network`: record each browser participant's requests to `network/<id>.ndjson`.
+ * `true` keeps the requests to the participant's target origin; `origins` adds up to 16 more exact
+ * http(s) origins. Only computer-use participants in hosted Chrome or Chromium on
+ * `execution.target: e2b-desktop` read it; every other route refuses it.
+ */
+export type StudyNetworkCapture = boolean | {
+    origins?: string[];
+};
 export interface StudyExecution {
     target?: StudyExecutionTarget;
     /** Actor session wall-clock budget. Consumed on the app-url route. */
@@ -582,6 +591,8 @@ export interface StudyExecution {
      */
     concurrency?: number;
     desktop?: StudyExecutionDesktop;
+    /** Each browser participant's network log; see StudyNetworkCapture. Absent or false: off. */
+    network?: StudyNetworkCapture;
     /** `terminal-product` route: the terminal transport + stdin posture. Consumed on that route. */
     terminal?: StudyExecutionTerminal;
     /** `terminal-product` route: runtime key placement, defaulting to openai-egress, an external

package/dist/study/validation.d.ts

@@ -1,3 +1,4 @@
+import { type StudyRoute } from "./routing.js";
 import type { StudyConfig } from "./types.js";
 /**
  * Cross-validate the computer-use fan-out declaration (`per-lane-worlds`). Returns the failure
@@ -21,6 +22,13 @@ export declare function smtpValidationReason(config: StudyConfig): string | unde
  * topology may not identify the backend that is actually executing.
  */
 export declare function desktopMediaValidationReason(config: StudyConfig, supportsMedia?: boolean): string | undefined;
+/**
+ * Why a study's `execution.network` cannot run where it is going, or undefined. Only a
+ * computer-use participant in hosted Chrome or Chromium has the in-sandbox DevTools client that
+ * records requests. Enforced at parse and again by each route's planner, which passes its own
+ * route, for a library caller's config.
+ */
+export declare function networkCaptureValidationReason(config: StudyConfig, route?: StudyRoute): string | undefined;
 /** Reused by direct library runners so unsupported receiving never becomes inert configuration. */
 export declare function receivingEmailValidationReason(config: StudyConfig): string | undefined;
 /** Refuse task declarations that the selected execution path would discard.

package/dist/study/validation.js

@@ -4,8 +4,8 @@ import { waitFieldsReason } from "../actors/computer-use/wait.js";
 import { PARTICIPANT_ID_MAX_CHARS, PARTICIPANT_ID_PATTERN } from "./parse/actors.js";
 import { isHttpUrl, isLoopbackUrl } from "./parse/subject.js";
 import { declaredTargets } from "./plan-participants.js";
-import { actorResolvesToComputerUse, computerUseParticipantCount, participantCountReason, registeredComputerUseActors, resolveEntryUrl, isComputerUseComposition, isScriptedBrowserComposition, isSharedWorldComposition, isTerminalProductComposition, } from "./routing.js";
-import { participantList } from "./study-fields.js";
+import { actorResolvesToComputerUse, computerUseParticipantCount, participantCountReason, registeredComputerUseActors, resolveEntryUrl, isComputerUseComposition, isScriptedBrowserComposition, isSharedWorldComposition, isTerminalProductComposition, routeOf, } from "./routing.js";
+import { networkCaptureOrigins, participantList } from "./study-fields.js";
 import { isStartAfterMs, rosterStartsReason, startAfterMessage, windowReason } from "./arrivals.js";
 /**
  * Cross-validate the computer-use fan-out declaration (`per-lane-worlds`). Returns the failure
@@ -206,6 +206,35 @@ export function desktopMediaValidationReason(config, supportsMedia = isComputerU
     }
     return undefined;
 }
+/**
+ * Why a study's `execution.network` cannot run where it is going, or undefined. Only a
+ * computer-use participant in hosted Chrome or Chromium has the in-sandbox DevTools client that
+ * records requests. Enforced at parse and again by each route's planner, which passes its own
+ * route, for a library caller's config.
+ */
+export function networkCaptureValidationReason(config, route = routeOf(config)) {
+    if (networkCaptureOrigins(config.execution?.network) === undefined)
+        return undefined;
+    const hosted = "only computer-use participants in hosted Chrome or Chromium on `execution.target: e2b-desktop` record their requests";
+    if (route === "terminal")
+        return "`execution.network` records each browser participant's requests, and route: terminal launches no browser: its participant works in a shell. Remove `execution.network`.";
+    if (route === "shared-world")
+        return "`execution.network` is not supported on route: shared-world yet: a shared world's lobby code sits in a page address the network log would keep, and that route keeps observed addresses only as digests. Remove `execution.network`, or run independent participants on route: computer-use.";
+    if (route === "scripted")
+        return `\`execution.network\` is not supported on route: scripted yet: ${hosted}. Remove \`execution.network\`.`;
+    if (route !== "computer-use")
+        return `\`execution.network\` is not read on route: ${route}: ${hosted}. Remove \`execution.network\`.`;
+    if (config.subject.source === "desktop-cli")
+        return "`execution.network` records each browser participant's requests, and a desktop-cli subject opens a terminal window and no browser, so there are none to record. Remove `execution.network`.";
+    if (config.subject.source === "local-app")
+        return `\`execution.network\` is not supported for a local-app subject: humanish does not launch that participant's browser, and ${hosted}. Remove \`execution.network\`.`;
+    const target = config.execution?.target;
+    if (target !== "e2b-desktop")
+        return `\`execution.network\` is not supported with \`execution.target: ${target ?? "(absent)"}\` yet: ${hosted}. Set \`execution.target: e2b-desktop\`, or remove \`execution.network\`.`;
+    if (config.execution?.desktop?.browser === "firefox")
+        return "`execution.network` needs Chrome or Chromium, and `execution.desktop.browser: firefox` launches Firefox with no DevTools port to record requests through. Set `execution.desktop.browser` to chrome, chromium or default, or remove `execution.network`.";
+    return undefined;
+}
 /** Reused by direct library runners so unsupported receiving never becomes inert configuration. */
 export function receivingEmailValidationReason(config) {
     if (config.comms?.email?.kind !== "real")

package/dist/substrates/detached.d.ts

@@ -27,6 +27,11 @@ export interface DetachedStepResult {
 }
 /** Read the capped log tail for a step (raw; caller redacts). */
 export declare function readDetachedLog(shell: Shell, name: string, requestTimeoutMs?: number): Promise<string>;
+/**
+ * Whether a process started by startDetachedProcess or runDetachedStep has exited. Its wrapper
+ * writes a status file however the command ended, a signal included.
+ */
+export declare function detachedProcessExited(shell: Shell, name: string, requestTimeoutMs?: number): Promise<boolean>;
 /**
  * Run a bounded step (install/build) detached, polling its atomic status file until it
  * exits or the budget runs out. On timeout the process group is killed and the log tail is

package/dist/substrates/detached.js

@@ -75,6 +75,15 @@ export async function readDetachedLog(shell, name, requestTimeoutMs = DEFAULT_RE
     const result = await runOrThrow(shell, `tail -c ${LOG_TAIL_BYTES} ${shellQuote(`${stepDir(name)}/log.txt`)} 2>/dev/null || true`, { requestTimeoutMs });
     return result.stdout;
 }
+/**
+ * Whether a process started by startDetachedProcess or runDetachedStep has exited. Its wrapper
+ * writes a status file however the command ended, a signal included.
+ */
+export async function detachedProcessExited(shell, name, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+    assertName(name);
+    const result = await runOrThrow(shell, `test -e ${shellQuote(`${stepDir(name)}/status`)} && echo exited || true`, { requestTimeoutMs });
+    return result.stdout.trim() === "exited";
+}
 /**
  * Run a bounded step (install/build) detached, polling its atomic status file until it
  * exits or the budget runs out. On timeout the process group is killed and the log tail is

package/dist/substrates/e2b/cdp-network-capture.d.ts

@@ -0,0 +1,23 @@
+/** The `network` field of a hold request. */
+export interface ChromeNetworkCaptureRequest {
+    /**
+     * Sandbox file the holder appends to; its folder is created. Defaults to
+     * /tmp/humanish-network/events.ndjson.
+     */
+    eventsPath?: string;
+    /** Origins, as `new URL(url).origin` writes them, whose request addresses the holder writes. */
+    origins: string[];
+}
+/**
+ * The capture half of the holder, spliced into CHROME_CDP_PROBE_PY so the shipped script stays one
+ * string. Line kinds: `start` (Network answered on the launch page), `request`, `response`,
+ * `servedFromCache`, `finished`, `failed`, `backForward` (a main-frame restore from the
+ * back-forward cache, which sends no request), `cap` (the file reached 32 MiB and writing stopped)
+ * and `exit` (the holder stopped; written in a finally). Ids are `<session>:<requestId>`, the
+ * session numbered in attach order from 0 for the launch page, because request ids repeat across
+ * renderers. `wallTime` is seconds since the epoch on the sandbox clock; `timestamp` is CDP's
+ * monotonic clock, for durations. A path longer than 4,096 characters ends at its last whole
+ * segment within them, then `/[TRUNCATED]`: the host redacts each segment, and a token cut in two
+ * can fall below the length its rules withhold.
+ */
+export declare const NETWORK_CAPTURE_PY: string;