browserscale-ts 1.8.0 → 1.10.0

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import type { Transport } from "@connectrpc/connect";
 import type { Locator } from "./locator.ts";
-import type { DOMResult, DragResult, ElementResult, EvaluateResult, InterceptedRequest, InterceptedResponse, InspectResult, NavigateResult, NetworkCaptureOptions, PageInfo, ScreenshotResult, ReadCanvasResult, SelectOptionResult, WaitResult, IceServer, StreamAnswer, ReactionInfo } from "./types.ts";
+import type { DOMResult, DragResult, ElementResult, EvaluateResult, InterceptedRequest, InterceptedResponse, InspectResult, NavigateResult, NetworkBody, NetworkBodyRange, NetworkCaptureOptions, PageInfo, ScreenshotResult, ReadCanvasResult, SelectOptionResult, SessionUsage, WaitResult, IceServer, StreamAnswer, ReactionInfo } from "./types.ts";
 import type { ClickOpts, FillOpts, GetDOMOpts, GetObservationOpts, LoadHTMLOpts, NavigateOpts, ReactionOpts, ScreenshotOpts, ReadCanvasOpts, SelectOpts, WaitOpts } from "./options.ts";
 import type { HeaderModification, RequestPattern } from "./network.ts";
 import { NetworkCapture, type NetworkExchangeHandler } from "./network-capture.ts";
@@ -25,7 +25,7 @@ export declare class CloudBrowser {
     private readonly _transport;
     private readonly _fingerprint;
     private readonly _stopFn?;
-    constructor(transport: Transport, sessionId: string, apiKey: string, fingerprint: string, stopFn?: () => Promise<void>);
+    constructor(transport: Transport, sessionId: string, apiKey: string, fingerprint: string, stopFn?: () => Promise<SessionUsage | undefined>);
     /** Returns the unique server-assigned id for this browser session. */
     getSessionId(): string;
     /** Returns the API key used to rent this session. */
@@ -40,13 +40,21 @@ export declare class CloudBrowser {
      * {@link createWebSocketBrowser} the rental stays untouched; only the
      * transport is closed.
      *
+     * @returns SessionUsage what the session consumed over its whole life, read
+     *   as it was torn down - no {@link CloudBrowser.getUsage} call is needed
+     *   before stopping. Undefined when the server could not report it, and for
+     *   a handle that owns no rental.
+     *
      * Rejects only when the stop API or the transport close fails. The session is
      * released either way; retrying a stop is safe.
      *
      * @example
-     * await browser.stopBrowser();
+     * const usage = await browser.stopBrowser();
+     * if (usage) {
+     *   console.log(`ran ${usage.wallTime}s, ${usage.cpuTime}s CPU, peak ${usage.peakMemory} bytes`);
+     * }
      */
-    stopBrowser(): Promise<void>;
+    stopBrowser(): Promise<SessionUsage | undefined>;
     /**
      * Changes the runtime proxy for this session.
      *
@@ -86,6 +94,27 @@ export declare class CloudBrowser {
      * for (const p of pages) console.log(p.url, p.title);
      */
     getPages(): Promise<PageInfo[]>;
+    /**
+     * Reports what this session's browser has consumed so far.
+     *
+     * Everything but minMemory and averageMemory only ever grows, so polling and
+     * diffing two readings gives the cost of what ran in between. The final
+     * figures need no call of their own: {@link CloudBrowser.stopBrowser} resolves
+     * with them.
+     *
+     * @returns SessionUsage as of now
+     *
+     * Rejects only on a transport failure - a dead session, a broken connection.
+     * This call has no semantic failure of its own, so there are no error codes to
+     * branch on.
+     *
+     * @example
+     * const before = await browser.getUsage();
+     * await browser.navigate("https://example.com");
+     * const after = await browser.getUsage();
+     * console.log(`navigation cost ${after.cpuTime - before.cpuTime}s of CPU`);
+     */
+    getUsage(): Promise<SessionUsage>;
     /**
      * Navigates the page to url.
      *
@@ -817,6 +846,55 @@ export declare class CloudBrowser {
      * is a no-op rather than a failure, so there are no error codes to branch on.
      */
     stopNetworkCapture(): Promise<boolean>;
+    /**
+     * Reads a whole captured body: an exchange's `requestBodyId` or
+     * `responseBodyId`.
+     *
+     * Bodies are stored by the browser, not sent with the exchange, so reading
+     * one is a separate call. They stay readable after the capture stops, until
+     * the session ends.
+     *
+     * The body is fetched in ranges and assembled in memory. For very large
+     * bodies, use {@link CloudBrowser.readNetworkBodyRange} to process them piece
+     * by piece.
+     *
+     * @param bodyId - `requestBodyId` or `responseBodyId` from a NetworkExchange
+     *
+     * @returns the body and whether the kept body is shorter than the original
+     *
+     * @throws not_found - no body with this id was kept in this session
+     * @throws evicted - the body was dropped to stay within the session's storage
+     *   quota; read bodies sooner, or narrow bodyPatterns
+     * @throws unavailable - the body could not be stored or read back
+     *
+     * @example
+     * const capture = await browser.captureNetwork(
+     *   { patterns: ["*\/api/*"], bodies: "text" },
+     *   (ex) => {
+     *     if (!ex.responseBodyId) return;
+     *     void browser.readNetworkBody(ex.responseBodyId).then(({ data }) =>
+     *       console.log(ex.url, new TextDecoder().decode(data)),
+     *     );
+     *   },
+     * );
+     */
+    readNetworkBody(bodyId: string): Promise<NetworkBody>;
+    /**
+     * Reads up to `length` bytes of a captured body starting at `offset`.
+     *
+     * A single call returns at most 2 MiB; omit `length` to read that much. Loop
+     * on `offset + data.length` until it reaches `totalSize` to stream a large
+     * body.
+     *
+     * @param bodyId - `requestBodyId` or `responseBodyId` from a NetworkExchange
+     * @param offset - first byte to read (default 0)
+     * @param length - bytes to read (default and maximum 2 MiB)
+     *
+     * @returns NetworkBodyRange with the bytes and the body's total size
+     *
+     * @inheritDoc CloudBrowser.readNetworkBody
+     */
+    readNetworkBodyRange(bodyId: string, offset?: number, length?: number): Promise<NetworkBodyRange>;
     /**
      * Subscribes to the session's capture without arming one, for reading a
      * capture that {@link CloudBrowser.startNetworkCapture} armed elsewhere.

package/dist/client.js

@@ -2,12 +2,12 @@ import { createClient } from "@connectrpc/connect";
 import { create } from "@bufbuild/protobuf";
 import { Browser, 
 // request / response schemas
-SetProxyRequestSchema, GetPagesRequestSchema, NavigateRequestSchema, LoadHTMLRequestSchema, EvaluateRequestSchema, WaitForAnyParamsSchema, WaitConditionSchema, ClickRequestSchema, FillRequestSchema, MoveToRequestSchema, ScrollToRequestSchema, DragRequestSchema, SelectOptionRequestSchema, GetDOMRequestSchema, GetDOMHashRequestSchema, GetObservationRequestSchema, ScreenshotRequestSchema, ReadCanvasRequestSchema, SetBlockListRequestSchema, SetStaticPathsRequestSchema, WaitForAnyRequestRequestSchema, WaitForAnyResponseRequestSchema, ModifyRequestRequestSchema, GetCookiesRequestSchema, SetCookiesRequestSchema, ClearCookiesRequestSchema, GetStorageRequestSchema, SetStorageRequestSchema, ClearStorageRequestSchema, GetAuthSessionRequestSchema, SetAuthSessionRequestSchema, InspectAtPositionRequestSchema, HighlightNodeRequestSchema, InsertTextRequestSchema, TypeRequestSchema, PressKeyRequestSchema, ReleaseKeyRequestSchema, GetSelectionRequestSchema, SolveCaptchaRequestSchema, GetStreamConfigRequestSchema, StartStreamRequestSchema, StopStreamRequestSchema, AddReactionRequestSchema, RemoveReactionRequestSchema, ListReactionsRequestSchema, StartNetworkCaptureRequestSchema, StopNetworkCaptureRequestSchema, StartDomMirrorRequestSchema, StopDomMirrorRequestSchema, GetDomChildrenRequestSchema, ReleaseDomSubtreeRequestSchema, RevealDomNodeRequestSchema, GetDomRevisionRequestSchema, StreamDomEventsRequestSchema, StreamNetworkExchangesRequestSchema, RunScriptRequestSchema, StartScriptRequestSchema, StopScriptsRequestSchema, ListScriptRunsRequestSchema, StreamScriptEventsRequestSchema, } from "./gen/wrc_pb.js";
+SetProxyRequestSchema, GetPagesRequestSchema, GetUsageRequestSchema, NavigateRequestSchema, LoadHTMLRequestSchema, EvaluateRequestSchema, WaitForAnyParamsSchema, WaitConditionSchema, ClickRequestSchema, FillRequestSchema, MoveToRequestSchema, ScrollToRequestSchema, DragRequestSchema, SelectOptionRequestSchema, GetDOMRequestSchema, GetDOMHashRequestSchema, GetObservationRequestSchema, ScreenshotRequestSchema, ReadCanvasRequestSchema, SetBlockListRequestSchema, SetStaticPathsRequestSchema, WaitForAnyRequestRequestSchema, WaitForAnyResponseRequestSchema, ModifyRequestRequestSchema, GetCookiesRequestSchema, SetCookiesRequestSchema, ClearCookiesRequestSchema, GetStorageRequestSchema, SetStorageRequestSchema, ClearStorageRequestSchema, GetAuthSessionRequestSchema, SetAuthSessionRequestSchema, InspectAtPositionRequestSchema, HighlightNodeRequestSchema, InsertTextRequestSchema, TypeRequestSchema, PressKeyRequestSchema, ReleaseKeyRequestSchema, GetSelectionRequestSchema, SolveCaptchaRequestSchema, GetStreamConfigRequestSchema, StartStreamRequestSchema, StopStreamRequestSchema, AddReactionRequestSchema, RemoveReactionRequestSchema, ListReactionsRequestSchema, StartNetworkCaptureRequestSchema, StopNetworkCaptureRequestSchema, StartDomMirrorRequestSchema, StopDomMirrorRequestSchema, GetDomChildrenRequestSchema, ReleaseDomSubtreeRequestSchema, RevealDomNodeRequestSchema, GetDomRevisionRequestSchema, StreamDomEventsRequestSchema, StreamNetworkExchangesRequestSchema, GetNetworkBodyRequestSchema, RunScriptRequestSchema, StartScriptRequestSchema, StopScriptsRequestSchema, ListScriptRunsRequestSchema, StreamScriptEventsRequestSchema, } from "./gen/wrc_pb.js";
 import { BrowserScaleError, CommandError, throwCommandError } from "./errors.js";
 import { NetworkCapture } from "./network-capture.js";
 import { ScriptFollow, ScriptRun, scriptLogEntryFromProto, } from "./scripts.js";
 import { DomMirror, } from "./dom-mirror.js";
-import { authSessionFromProto, authSessionToProto, cookieParamFromProto, cookieParamsToProto, elementFields, headerModsToProto, headersToProto, interceptedRequestFromProto, interceptedResponseFromProto, pageInfoFromProto, rectFromProto, splitRequestPatterns, storageEntriesToProto, storageEntryFromProto, unwrapClick, unwrapDrag, unwrapFill, unwrapMove, unwrapScroll, unwrapSelect, unwrapWait, } from "./internal/convert.js";
+import { authSessionFromProto, authSessionToProto, cookieParamFromProto, cookieParamsToProto, elementFields, headerModsToProto, headersToProto, interceptedRequestFromProto, interceptedResponseFromProto, pageInfoFromProto, rectFromProto, sessionUsageFromProto, splitRequestPatterns, storageEntriesToProto, storageEntryFromProto, unwrapClick, unwrapDrag, unwrapFill, unwrapMove, unwrapScroll, unwrapSelect, unwrapWait, } from "./internal/convert.js";
 /**
  * CloudBrowser is the SDK-side handle for an active browserscale browser session.
  *
@@ -49,16 +49,25 @@ export class CloudBrowser {
      * {@link createWebSocketBrowser} the rental stays untouched; only the
      * transport is closed.
      *
+     * @returns SessionUsage what the session consumed over its whole life, read
+     *   as it was torn down - no {@link CloudBrowser.getUsage} call is needed
+     *   before stopping. Undefined when the server could not report it, and for
+     *   a handle that owns no rental.
+     *
      * Rejects only when the stop API or the transport close fails. The session is
      * released either way; retrying a stop is safe.
      *
      * @example
-     * await browser.stopBrowser();
+     * const usage = await browser.stopBrowser();
+     * if (usage) {
+     *   console.log(`ran ${usage.wallTime}s, ${usage.cpuTime}s CPU, peak ${usage.peakMemory} bytes`);
+     * }
      */
     async stopBrowser() {
         if (this._stopFn) {
-            await this._stopFn();
+            return await this._stopFn();
         }
+        return undefined;
     }
     // ──────────────────────────────────────────────────────────────────
     // Context-level
@@ -124,6 +133,37 @@ export class CloudBrowser {
         throwCommandError("getPages", resp.error);
         return resp.pages.map(pageInfoFromProto);
     }
+    /**
+     * Reports what this session's browser has consumed so far.
+     *
+     * Everything but minMemory and averageMemory only ever grows, so polling and
+     * diffing two readings gives the cost of what ran in between. The final
+     * figures need no call of their own: {@link CloudBrowser.stopBrowser} resolves
+     * with them.
+     *
+     * @returns SessionUsage as of now
+     *
+     * Rejects only on a transport failure - a dead session, a broken connection.
+     * This call has no semantic failure of its own, so there are no error codes to
+     * branch on.
+     *
+     * @example
+     * const before = await browser.getUsage();
+     * await browser.navigate("https://example.com");
+     * const after = await browser.getUsage();
+     * console.log(`navigation cost ${after.cpuTime - before.cpuTime}s of CPU`);
+     */
+    async getUsage() {
+        const resp = await this.client.getUsage(create(GetUsageRequestSchema, {
+            sessionId: this.sessionId,
+            apiKey: this.apiKey,
+        }));
+        throwCommandError("getUsage", resp.error);
+        if (!resp.usage) {
+            throw new BrowserScaleError("getUsage: the server sent no usage");
+        }
+        return sessionUsageFromProto(resp.usage);
+    }
     // ──────────────────────────────────────────────────────────────────
     // Page navigation / content
     // ──────────────────────────────────────────────────────────────────
@@ -1236,6 +1276,94 @@ export class CloudBrowser {
         throwCommandError("stopNetworkCapture", resp.error);
         return resp.stopped;
     }
+    /**
+     * Reads a whole captured body: an exchange's `requestBodyId` or
+     * `responseBodyId`.
+     *
+     * Bodies are stored by the browser, not sent with the exchange, so reading
+     * one is a separate call. They stay readable after the capture stops, until
+     * the session ends.
+     *
+     * The body is fetched in ranges and assembled in memory. For very large
+     * bodies, use {@link CloudBrowser.readNetworkBodyRange} to process them piece
+     * by piece.
+     *
+     * @param bodyId - `requestBodyId` or `responseBodyId` from a NetworkExchange
+     *
+     * @returns the body and whether the kept body is shorter than the original
+     *
+     * @throws not_found - no body with this id was kept in this session
+     * @throws evicted - the body was dropped to stay within the session's storage
+     *   quota; read bodies sooner, or narrow bodyPatterns
+     * @throws unavailable - the body could not be stored or read back
+     *
+     * @example
+     * const capture = await browser.captureNetwork(
+     *   { patterns: ["*\/api/*"], bodies: "text" },
+     *   (ex) => {
+     *     if (!ex.responseBodyId) return;
+     *     void browser.readNetworkBody(ex.responseBodyId).then(({ data }) =>
+     *       console.log(ex.url, new TextDecoder().decode(data)),
+     *     );
+     *   },
+     * );
+     */
+    async readNetworkBody(bodyId) {
+        const parts = [];
+        let offset = 0;
+        for (;;) {
+            const r = await this.readNetworkBodyRange(bodyId, offset);
+            parts.push(r.data);
+            offset += r.data.length;
+            if (r.data.length === 0 || offset >= r.totalSize) {
+                if (parts.length === 1)
+                    return { data: r.data, truncated: r.truncated };
+                const data = new Uint8Array(offset);
+                let at = 0;
+                for (const p of parts) {
+                    data.set(p, at);
+                    at += p.length;
+                }
+                return { data, truncated: r.truncated };
+            }
+        }
+    }
+    /**
+     * Reads up to `length` bytes of a captured body starting at `offset`.
+     *
+     * A single call returns at most 2 MiB; omit `length` to read that much. Loop
+     * on `offset + data.length` until it reaches `totalSize` to stream a large
+     * body.
+     *
+     * @param bodyId - `requestBodyId` or `responseBodyId` from a NetworkExchange
+     * @param offset - first byte to read (default 0)
+     * @param length - bytes to read (default and maximum 2 MiB)
+     *
+     * @returns NetworkBodyRange with the bytes and the body's total size
+     *
+     * @inheritDoc CloudBrowser.readNetworkBody
+     */
+    async readNetworkBodyRange(bodyId, offset, length) {
+        if (!bodyId) {
+            throw new BrowserScaleError("browserscale.readNetworkBody: bodyId must not be empty");
+        }
+        const req = create(GetNetworkBodyRequestSchema, {
+            sessionId: this.sessionId,
+            apiKey: this.apiKey,
+            bodyId,
+        });
+        if (offset && offset > 0)
+            req.offset = BigInt(Math.floor(offset));
+        if (length && length > 0)
+            req.length = BigInt(Math.floor(length));
+        const resp = await this.client.getNetworkBody(req);
+        throwCommandError("getNetworkBody", resp.error);
+        return {
+            data: resp.data,
+            totalSize: Number(resp.totalSize),
+            truncated: resp.truncated,
+        };
+    }
     /**
      * Subscribes to the session's capture without arming one, for reading a
      * capture that {@link CloudBrowser.startNetworkCapture} armed elsewhere.

package/dist/gen/wrc_pb.d.ts

@@ -1453,6 +1453,113 @@ export type GetPagesResponse = Message<"browserscale.v1.GetPagesResponse"> & {
  * Use `create(GetPagesResponseSchema)` to create a new message.
  */
 export declare const GetPagesResponseSchema: GenMessage<GetPagesResponse>;
+/**
+ * What a session's browser has consumed since the session started: the CPU
+ * time and memory of every process that rendered its pages — main frames,
+ * cross-site iframes and the workers they host — including processes that have
+ * since exited. Work done on the session's behalf in processes it shares with
+ * other sessions is not included. The stop endpoint returns the same object, in
+ * its JSON form, as the session's final usage.
+ *
+ * @generated from message browserscale.v1.SessionUsage
+ */
+export type SessionUsage = Message<"browserscale.v1.SessionUsage"> & {
+    /**
+     * Real time since the session's browser was created, in seconds.
+     *
+     * @generated from field: double wall_time = 1;
+     */
+    wallTime: number;
+    /**
+     * CPU time in seconds, user plus kernel. Only time a thread actually ran on a
+     * core counts; waiting and idling do not.
+     *
+     * @generated from field: double cpu_time = 2;
+     */
+    cpuTime: number;
+    /**
+     * The least memory the session held once its browser was ready, in bytes.
+     * Sampled about once a second.
+     *
+     * @generated from field: double min_memory = 3;
+     */
+    minMemory: number;
+    /**
+     * The memory held, averaged over wall_time, in bytes; average_memory *
+     * wall_time is the memory-time used. Sampled about once a second, so short
+     * spikes count toward the peak but barely toward the average.
+     *
+     * @generated from field: double average_memory = 4;
+     */
+    averageMemory: number;
+    /**
+     * The most memory held at any one moment, in bytes.
+     *
+     * @generated from field: double peak_memory = 5;
+     */
+    peakMemory: number;
+    /**
+     * Renderer processes that hosted at least one of the session's frames: one
+     * per site its pages and cross-site iframes needed.
+     *
+     * @generated from field: int32 renderers_used = 6;
+     */
+    renderersUsed: number;
+    /**
+     * Child frames created in the session's pages, whether or not they got a
+     * process of their own.
+     *
+     * @generated from field: int32 frames_created = 7;
+     */
+    framesCreated: number;
+};
+/**
+ * Describes the message browserscale.v1.SessionUsage.
+ * Use `create(SessionUsageSchema)` to create a new message.
+ */
+export declare const SessionUsageSchema: GenMessage<SessionUsage>;
+/**
+ * @generated from message browserscale.v1.GetUsageRequest
+ */
+export type GetUsageRequest = Message<"browserscale.v1.GetUsageRequest"> & {
+    /**
+     * @generated from field: string session_id = 1;
+     */
+    sessionId: string;
+    /**
+     * @generated from field: string api_key = 2;
+     */
+    apiKey: string;
+};
+/**
+ * Describes the message browserscale.v1.GetUsageRequest.
+ * Use `create(GetUsageRequestSchema)` to create a new message.
+ */
+export declare const GetUsageRequestSchema: GenMessage<GetUsageRequest>;
+/**
+ * @generated from message browserscale.v1.GetUsageResponse
+ */
+export type GetUsageResponse = Message<"browserscale.v1.GetUsageResponse"> & {
+    /**
+     * @generated from field: browserscale.v1.SessionUsage usage = 1;
+     */
+    usage?: SessionUsage;
+    /**
+     * Always true today: this command has no semantic failure of its own.
+     *
+     * @generated from field: bool success = 2;
+     */
+    success: boolean;
+    /**
+     * @generated from field: optional browserscale.v1.CommandError error = 3;
+     */
+    error?: CommandError;
+};
+/**
+ * Describes the message browserscale.v1.GetUsageResponse.
+ * Use `create(GetUsageResponseSchema)` to create a new message.
+ */
+export declare const GetUsageResponseSchema: GenMessage<GetUsageResponse>;
 /**
  * @generated from message browserscale.v1.NavigateRequest
  */
@@ -2255,14 +2362,15 @@ export type StartNetworkCaptureRequest = Message<"browserscale.v1.StartNetworkCa
      */
     patterns: string[];
     /**
-     * Response body capture: "none" (default), "text" or "all".
+     * Response body capture: "none" (default), "text" or "all". Request bodies
+     * are kept whenever a request has one.
      *
      * @generated from field: string bodies = 4;
      */
     bodies: string;
     /**
-     * Narrows body capture further; empty applies `bodies` to every captured
-     * exchange.
+     * Narrows response body capture further; empty applies `bodies` to every
+     * captured exchange.
      *
      * @generated from field: repeated string body_patterns = 5;
      */
@@ -2433,13 +2541,22 @@ export type NetworkExchange = Message<"browserscale.v1.NetworkExchange"> & {
      */
     requestHeadersAreWire: boolean;
     /**
-     * Inline request body, capped by the browser. File and streamed uploads are
-     * not included; request_body_truncated is set when anything was left out.
+     * Bodies never travel with the exchange. Pass the id to GetNetworkBody to
+     * read the bytes; empty when the request had no body.
      *
-     * @generated from field: bytes request_body = 12;
+     * @generated from field: string request_body_id = 28;
      */
-    requestBody: Uint8Array;
+    requestBodyId: string;
     /**
+     * Bytes kept for the request body.
+     *
+     * @generated from field: int64 request_body_size = 29;
+     */
+    requestBodySize: bigint;
+    /**
+     * True when part of the request body is missing: it hit the per-body cap, or
+     * it was a file or streamed upload, which are not kept.
+     *
      * @generated from field: bool request_body_truncated = 13;
      */
     requestBodyTruncated: boolean;
@@ -2486,21 +2603,25 @@ export type NetworkExchange = Message<"browserscale.v1.NetworkExchange"> & {
      */
     responseHeadersAreWire: boolean;
     /**
-     * Populated only when body capture was requested and applied. Bodies cross
-     * the browser boundary as text, so binary content (bodies="all" on an image)
-     * does not arrive intact.
+     * Pass to GetNetworkBody to read the response body. Empty when body capture
+     * did not apply to this exchange.
      *
-     * @generated from field: bytes response_body = 23;
+     * @generated from field: string response_body_id = 30;
      */
-    responseBody: Uint8Array;
+    responseBodyId: string;
     /**
-     * @generated from field: bool response_body_truncated = 24;
+     * Bytes kept for the response body, after content decoding.
+     *
+     * @generated from field: int64 response_body_size = 31;
      */
-    responseBodyTruncated: boolean;
+    responseBodySize: bigint;
     /**
-     * @generated from field: bool response_body_captured = 25;
+     * True when the kept body is shorter than the one the page received: it hit
+     * the per-body cap, the load ended early, or the host's disk fell behind.
+     *
+     * @generated from field: bool response_body_truncated = 24;
      */
-    responseBodyCaptured: boolean;
+    responseBodyTruncated: boolean;
     /**
      * @generated from field: int64 encoded_data_length = 26;
      */
@@ -2517,6 +2638,84 @@ export type NetworkExchange = Message<"browserscale.v1.NetworkExchange"> & {
  * Use `create(NetworkExchangeSchema)` to create a new message.
  */
 export declare const NetworkExchangeSchema: GenMessage<NetworkExchange>;
+/**
+ * @generated from message browserscale.v1.GetNetworkBodyRequest
+ */
+export type GetNetworkBodyRequest = Message<"browserscale.v1.GetNetworkBodyRequest"> & {
+    /**
+     * @generated from field: string session_id = 1;
+     */
+    sessionId: string;
+    /**
+     * @generated from field: string api_key = 2;
+     */
+    apiKey: string;
+    /**
+     * request_body_id or response_body_id of an exchange.
+     *
+     * @generated from field: string body_id = 3;
+     */
+    bodyId: string;
+    /**
+     * First byte to read; 0 when unset.
+     *
+     * @generated from field: optional int64 offset = 4;
+     */
+    offset?: bigint;
+    /**
+     * Bytes to read. Unset or larger than the per-call limit (2 MiB) reads up to
+     * that limit; larger bodies are read in ranges.
+     *
+     * @generated from field: optional int64 length = 5;
+     */
+    length?: bigint;
+};
+/**
+ * Describes the message browserscale.v1.GetNetworkBodyRequest.
+ * Use `create(GetNetworkBodyRequestSchema)` to create a new message.
+ */
+export declare const GetNetworkBodyRequestSchema: GenMessage<GetNetworkBodyRequest>;
+/**
+ * @generated from message browserscale.v1.GetNetworkBodyResponse
+ */
+export type GetNetworkBodyResponse = Message<"browserscale.v1.GetNetworkBodyResponse"> & {
+    /**
+     * The bytes read; empty past the end of the body.
+     *
+     * @generated from field: bytes data = 1;
+     */
+    data: Uint8Array;
+    /**
+     * Bytes kept for this body in total.
+     *
+     * @generated from field: int64 total_size = 2;
+     */
+    totalSize: bigint;
+    /**
+     * Same as the exchange's truncated flag for this body.
+     *
+     * @generated from field: bool truncated = 3;
+     */
+    truncated: boolean;
+    /**
+     * False iff the body cannot be read; then error carries the code:
+     *   "not_found" — no body with this id was kept in this session.
+     *   "evicted" — the body was dropped to stay within the session's quota.
+     *   "unavailable" — the body could not be stored or read back.
+     *
+     * @generated from field: bool success = 4;
+     */
+    success: boolean;
+    /**
+     * @generated from field: optional browserscale.v1.CommandError error = 5;
+     */
+    error?: CommandError;
+};
+/**
+ * Describes the message browserscale.v1.GetNetworkBodyResponse.
+ * Use `create(GetNetworkBodyResponseSchema)` to create a new message.
+ */
+export declare const GetNetworkBodyResponseSchema: GenMessage<GetNetworkBodyResponse>;
 /**
  * @generated from message browserscale.v1.GetCookiesRequest
  */
@@ -4641,6 +4840,17 @@ export declare const Browser: GenService<{
         input: typeof GetPagesRequestSchema;
         output: typeof GetPagesResponseSchema;
     };
+    /**
+     * What the session has consumed so far. The final figures need no call of
+     * their own: the stop endpoint returns them.
+     *
+     * @generated from rpc browserscale.v1.Browser.GetUsage
+     */
+    getUsage: {
+        methodKind: "unary";
+        input: typeof GetUsageRequestSchema;
+        output: typeof GetUsageResponseSchema;
+    };
     /**
      * Page navigation / content
      *
@@ -4803,7 +5013,8 @@ export declare const Browser: GenService<{
      * Network capture — every matching request in the session, reported as it
      * completes. Start/Stop are session state; the stream is a separate
      * subscription, so a capture survives a reader reconnect and two readers
-     * can watch one capture.
+     * can watch one capture. Exchanges only name their bodies; GetNetworkBody
+     * reads them.
      *
      * @generated from rpc browserscale.v1.Browser.StartNetworkCapture
      */
@@ -4828,6 +5039,14 @@ export declare const Browser: GenService<{
         input: typeof StreamNetworkExchangesRequestSchema;
         output: typeof NetworkExchangeEventSchema;
     };
+    /**
+     * @generated from rpc browserscale.v1.Browser.GetNetworkBody
+     */
+    getNetworkBody: {
+        methodKind: "unary";
+        input: typeof GetNetworkBodyRequestSchema;
+        output: typeof GetNetworkBodyResponseSchema;
+    };
     /**
      * Cookies
      *