withruntime 0.33.2 → 0.34.0

package/dist/products/agents.js

@@ -22,7 +22,9 @@ import { Page } from "../page.js";
 const START = 'npx -y @anthropic-ai/claude-code --dangerously-skip-permissions --mcp-config ~/.runtime-agent/mcp.json -p "$(cat ~/.runtime-agent/start.md)"';
 const CODEX = 'npx -y @openai/codex exec --dangerously-bypass-approvals-and-sandbox "$(cat ~/.runtime-agent/start.md)"';
 const GEMINI = 'npx -y @google/gemini-cli --yolo -p "$(cat ~/.runtime-agent/start.md)"';
-/** The five harnesses (agents-contract.md); tests/agents.test.ts holds them
+const REVIEW = "python3 ~/.runtime-agent/runtime-agent review";
+const JUDGE = "python3 ~/.runtime-agent/runtime-agent judge";
+/** The harnesses (agents-contract.md); tests/agents.test.ts holds them
  * to packages/cloud-guide/agent-templates.json. */
 export const AGENT_TEMPLATES = {
     "claude-code": {
@@ -70,6 +72,36 @@ export const AGENT_TEMPLATES = {
         subscription: null,
         definition: { command: "python3 ~/agent.py", secrets: ["OPENAI_API_KEY"] },
     },
+    review: {
+        key: "review",
+        title: "Code review",
+        command: REVIEW,
+        apiKeySecret: "ANTHROPIC_API_KEY",
+        apiKeyHost: "api.anthropic.com",
+        subscription: "a token per account: run `claude setup-token` on your own computer (Pro/Max) for each, store each with `runtime secrets set CLAUDE_1` scoped to api.anthropic.com, then name them all in pool (--pool CLAUDE_1 --pool CLAUDE_2)",
+        definition: {
+            command: REVIEW,
+            pool: ["ANTHROPIC_API_KEY"],
+            vcpu: 2,
+            memoryMiB: 2048,
+            maxSessionSeconds: 1800,
+        },
+    },
+    judge: {
+        key: "judge",
+        title: "Your rules",
+        command: JUDGE,
+        apiKeySecret: "ANTHROPIC_API_KEY",
+        apiKeyHost: "api.anthropic.com",
+        subscription: "a token per account, as for review: `runtime secrets set CLAUDE_1` scoped to api.anthropic.com for each, then name them all in pool; its instructions are the rules that block",
+        definition: {
+            command: JUDGE,
+            pool: ["ANTHROPIC_API_KEY"],
+            vcpu: 2,
+            memoryMiB: 2048,
+            maxSessionSeconds: 1800,
+        },
+    },
 };
 /** A harness by a key read from a file or a flag, or undefined. */
 export function agentTemplate(key) {
@@ -166,6 +198,28 @@ export function agents(t) {
         });
         return new Page(page.data, page.nextCursor, (cursor) => listSessions({ ...query, cursor }, options));
     };
+    const listAsks = async (query = {}, options) => {
+        const { labels, ...rest } = query;
+        const page = await t.json({
+            method: "GET",
+            path: "/v1/agents/asks",
+            query: {
+                ...rest,
+                ...(labels ? { label: Object.entries(labels).map(([k, v]) => `${k}:${v}`) } : {}),
+            },
+            ...options,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => listAsks({ ...query, cursor }, options));
+    };
+    const listHeld = async (trigger, query = {}, options) => {
+        const page = await t.json({
+            method: "GET",
+            path: `/v1/agents/triggers/${enc(trigger)}/held`,
+            query,
+            ...options,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => listHeld(trigger, { ...query, cursor }, options));
+    };
     const listMemory = async (agent, query = {}, options) => {
         const page = await t.json({
             method: "GET",
@@ -227,6 +281,21 @@ export function agents(t) {
                 });
             },
         },
+        /** The account's inbox: the questions its agents' sessions need answered
+         * to go on, one row per step however many sessions ask it. */
+        asks: {
+            /** Newest first; open ones unless `state` says otherwise. */
+            list: listAsks,
+            get: (id, options) => t.json({ method: "GET", path: `/v1/agents/asks/${enc(id)}`, ...options }),
+            /** Every session asking it reads the answer next, and wakes. An ask no
+             * longer open is refused with `ask_closed`. */
+            answer: (id, answer, options) => t.json({
+                method: "POST",
+                path: `/v1/agents/asks/${enc(id)}/answer`,
+                body: answer,
+                ...options,
+            }),
+        },
         triggers: {
             create: (agent, input, options) => t.json({
                 method: "POST",
@@ -239,7 +308,8 @@ export function agents(t) {
                 path: `/v1/agents/${enc(agent)}/triggers`,
                 ...options,
             })).data,
-            /** Its events are refused, saying `why`; nothing else is held. */
+            /** Held: a webhook's calls are kept for you (see `held`), saying
+             * `why`; nothing else is held. */
             pause: (id, why, options) => t.json({
                 method: "POST",
                 path: `/v1/agents/triggers/${enc(id)}/pause`,
@@ -259,6 +329,40 @@ export function agents(t) {
                     ...options,
                 });
             },
+            /** Its rules, whole, in place: its secret stays. `{}` is every default. */
+            setRules: (id, rules, options) => t.json({
+                method: "PATCH",
+                path: `/v1/agents/triggers/${enc(id)}`,
+                body: { rules },
+                ...options,
+            }),
+            /** A webhook trigger's call, as its sender makes it: by the trigger's
+             * secret, never your key. A call with the key of an open session joins
+             * it. Pass `idempotencyKey` to make a retry the same call. */
+            call: (id, secret, call, options) => t.json({
+                method: "POST",
+                path: `/v1/agents/triggers/${enc(id)}/calls`,
+                body: call,
+                bearer: secret,
+                ...options,
+            }),
+            /** Calls it held for you, newest first. */
+            held: listHeld,
+            /** Start a held call: one session with it and every call held for its
+             * key since, oldest first. */
+            startHeld: (id, call, options) => t.json({
+                method: "POST",
+                path: `/v1/agents/triggers/${enc(id)}/held/${enc(call)}/start`,
+                body: {},
+                ...options,
+            }),
+            /** Dismiss a held call: nothing runs. */
+            dismissHeld: (id, call, options) => t.json({
+                method: "POST",
+                path: `/v1/agents/triggers/${enc(id)}/held/${enc(call)}/dismiss`,
+                body: {},
+                ...options,
+            }),
         },
         /** Its built-in memory: text files kept across sessions, which the
          * agent reads, writes and searches from inside its sessions. A scope is
@@ -292,7 +396,8 @@ export function agents(t) {
             })).deleted,
         },
         /** The harnesses, as data: claude-code, codex, gemini-cli,
-         * claude-agent-sdk, openai-agents-sdk. */
+         * claude-agent-sdk, openai-agents-sdk, review (a CI/CD agent step's
+         * reviewer) and judge (an agent step held to your instructions alone). */
         templates: AGENT_TEMPLATES,
         /** The uses, as data: support (your customers) and team (your team). */
         uses: AGENT_USES,

package/dist/products/apps.d.ts

@@ -39,7 +39,42 @@ export type StatefulSettings = {
     /** Seconds a stopped copy has after SIGTERM to exit. */
     stopGraceSeconds: number;
 };
-export type App = AppSettings & StatefulSettings & {
+/** How an App's new version goes live: every copy together (at_once, the
+ * default), or staged: one copy of it beside the live version's, then about
+ * 10%, 50% and all of them, each stage judged on its visitors' errors and
+ * speed before the next. A stage that does worse goes back: its copies
+ * finish their requests and stop, then the deploy fails (deploy_stage_failed)
+ * and the live version never stops serving. */
+export type ReleaseStages = "at_once" | "staged";
+export type ReleaseSettings = {
+    releaseStages: ReleaseStages;
+    /** 60 to 3600 seconds; defaults to 300. How long each stage runs once its
+     * copies serve before it is judged. */
+    releaseSoakSeconds: number;
+};
+/** An App's staged release under way, or its last. */
+export type StagedRelease = {
+    version: number;
+    /** The version live when it began, serving beside it. */
+    from: number;
+    /** rolling: its stages go live; back: a stage did worse and its copies
+     * leave; done: every copy runs it; failed: it went back (or its copies
+     * failed their health check) and the version failed; ended: another
+     * deploy or a rollback took its place. */
+    state: "rolling" | "back" | "done" | "failed" | "ended";
+    stage: number;
+    stages: number;
+    /** Copies of the new version the stage serves beside the old version's. */
+    copies: number;
+    /** Copies the release walks to. */
+    of: number;
+    soakSeconds: number;
+    /** Its last step, in words. */
+    detail: string;
+    startedAt: number;
+    updatedAt: number;
+};
+export type App = AppSettings & StatefulSettings & ReleaseSettings & {
     id: string;
     name: string | null;
     /** Its address for life, its name then its account's:
@@ -58,6 +93,8 @@ export type App = AppSettings & StatefulSettings & {
     } | null;
     liveVersion: number | null;
     previousVersion: number | null;
+    /** Its staged release under way, or its last; null before its first. */
+    stagedRelease: StagedRelease | null;
     /** While a copy waits for room in its region: its account's lane, its
      * place in line (1 is next), how many wait ahead by lane, and why.
      * Higher lanes get room first. Absent while nothing of it waits. */
@@ -69,7 +106,7 @@ export type AppLine = {
     ahead: Record<string, number>;
     words: string;
 };
-export type RuntimeFunction = Omit<App, "minCopies" | keyof StatefulSettings> & {
+export type RuntimeFunction = Omit<App, "minCopies" | keyof StatefulSettings | keyof ReleaseSettings | "stagedRelease"> & {
     minCopies: 0;
     /** 250 to 5000 ms: at most how long a copy stays awake after its last request ends. */
     sleepAfterMs: number;
@@ -125,14 +162,18 @@ export type CreateApp = Omit<CreateFunction, "minCopies" | "sleepAfterMs"> & {
     volume?: AppVolume;
     /** 0 to 900; defaults to 30. */
     stopGraceSeconds?: number;
+    /** Defaults to "at_once"; see ReleaseStages. */
+    releaseStages?: ReleaseStages;
+    /** 60 to 3600; defaults to 300. */
+    releaseSoakSeconds?: number;
 };
-export type UpdateApp = Partial<AppSettings & StatefulSettings> & {
+export type UpdateApp = Partial<AppSettings & StatefulSettings & ReleaseSettings> & {
     name?: string | null;
     labels?: Record<string, string>;
     /** Only Functions sleep on this rule; an App is refused it. */
     sleepAfterMs?: never;
 };
-export type UpdateFunction = Omit<UpdateApp, "minCopies" | "sleepAfterMs" | keyof StatefulSettings> & {
+export type UpdateFunction = Omit<UpdateApp, "minCopies" | "sleepAfterMs" | keyof StatefulSettings | keyof ReleaseSettings> & {
     minCopies?: never;
     /** 250 to 5000 ms; see CreateFunction.sleepAfterMs. */
     sleepAfterMs?: number;
@@ -159,7 +200,7 @@ export type AppDeploy = {
 } | {
     state: "failed" | "superseded";
     error: {
-        code: "deploy_build_failed" | "deploy_health_failed" | "deploy_stop_failed" | "deploy_switch_failed" | "deploy_superseded";
+        code: "deploy_build_failed" | "deploy_health_failed" | "deploy_stop_failed" | "deploy_stage_failed" | "deploy_switch_failed" | "deploy_superseded";
         message: string;
         hint: string;
         lastOutput: string;

package/dist/products/browsers.d.ts

@@ -40,6 +40,28 @@ export type BrowserInfo = {
     liveViewUrl?: string;
     hint?: string;
 };
+export type BrowserScreenshot = {
+    /** An http(s) address, opened in a new tab that is closed after. */
+    url?: string;
+    /** The whole page, not only the window. */
+    fullPage?: boolean;
+    format?: "png" | "jpeg";
+    /** 0 to 10000 ms after the page loads, for late scripts. */
+    waitMs?: number;
+};
+export type BrowserScreenshotResult = {
+    /** Where the page ended, after redirects. */
+    url: string;
+    title: string;
+    /** The page's HTTP status; null for the page already shown. */
+    status: number | null;
+    mimeType: "image/png" | "image/jpeg";
+    bytes: number;
+    width: number | null;
+    height: number | null;
+    /** The image. */
+    base64: string;
+};
 export type BrowserConnectOptions = {
     playwright: [endpointURL: string, options: {
         headers: Record<string, string>;
@@ -66,6 +88,10 @@ export declare function browsers(t: Transport): {
     list: (query?: ListBrowsers, options?: RequestOptions) => Promise<Page<Browser>>;
     /** Change a browser's name or labels without changing its compute settings. */
     update(id: string, input: UpdateBrowser, options?: RequestOptions): Promise<Browser>;
+    /** Open `url` in a new tab and shoot it once it loads (without `url`, what
+     * the browser shows now); the image is `base64`, its page's url, title
+     * and HTTP status beside it. Runs inside the browser's own sandbox. */
+    screenshot(id: string, input?: BrowserScreenshot, options?: RequestOptions): Promise<BrowserScreenshotResult>;
     /** End a browser by id; pass RequestOptions to bound or deduplicate the request. */
     delete: (id: string, options?: RequestOptions) => Promise<void>;
 };

package/dist/products/browsers.js

@@ -96,6 +96,17 @@ export function browsers(t) {
                 ...options,
             }));
         },
+        /** Open `url` in a new tab and shoot it once it loads (without `url`, what
+         * the browser shows now); the image is `base64`, its page's url, title
+         * and HTTP status beside it. Runs inside the browser's own sandbox. */
+        screenshot(id, input = {}, options) {
+            return t.json({
+                method: "POST",
+                path: `${path(id)}:screenshot`,
+                body: input,
+                ...options,
+            });
+        },
         /** End a browser by id; pass RequestOptions to bound or deduplicate the request. */
         delete: remove,
     };

package/dist/products/ci.d.ts

@@ -65,7 +65,7 @@ export type CiCheck = {
     /** The GitHub login that pushed, opened or re-ran it. */
     actor: string | null;
     /** The repository's writers' code. A fork's pull request is not, and runs
-     * nothing until a writer re-runs it on GitHub. */
+     * nothing; a writer can open it again from a branch of the repository. */
     trusted: boolean;
     /** Queued for a writer's approval: nothing of it runs. */
     waiting: boolean;
@@ -144,7 +144,8 @@ export type CiReviewFinding = {
     /** What would put it right. */
     fix: string;
 };
-/** A review step's verdict on one commit: it passes only with no findings. */
+/** An agent step's verdict on one commit (`review:` is its short form): it
+ * passes only with no findings. */
 export type CiReview = {
     verdict: "pass" | "block";
     summary: string;
@@ -155,10 +156,11 @@ export type CiReview = {
         line: number;
         what: string;
     }[];
-    /** The Runtime Agent that reviewed, the account it ran on and its model. */
+    /** The Runtime Agent that judged, and the model the step asked for. */
     agent: string;
-    account: string;
-    model: string;
+    model: string | null;
+    /** The Claude account a verdict before agent steps ran on. */
+    account?: string;
     /** The agent session that gave the verdict. */
     session: string;
     /** True when the diff was too long and its end was not read. */
@@ -168,6 +170,12 @@ export type CiReview = {
 export type CiCheckDetail = CiCheck & {
     jobs: CiJob[];
 };
+/** A cancel's answer to a key that may cancel the check but not read it:
+ * its id and state, nothing of its jobs or logs. */
+export type CiCancelled = {
+    id: string;
+    state: CiCheckState;
+};
 /** A job with the tail of its output: at most 256 KiB, the oldest dropped first. */
 export type CiJobDetail = CiJob & {
     log: string;
@@ -291,6 +299,30 @@ export type UpdateCiFlake = {
     owner?: string;
     deleteReason?: string;
 };
+/** One step a release took, as it took it: a migration's copy test or
+ * apply, a deploy ref moved, a server's canary or release, the website's
+ * deploy or promote, or a wait with why. */
+export type CiReleaseStep = {
+    id: number;
+    repositoryId: string;
+    /** The commit this step of the release is of. */
+    commit: string;
+    /** Who took it: `mover` (the release on CI/CD's pass) or the deploy
+     * target that walks it (`hostd`, `controller`, `settings`, `follower`). */
+    source: string;
+    /** The server it was on, when it was on one. */
+    host: string | null;
+    line: string;
+    /** Unix milliseconds. */
+    at: number;
+};
+export type ListCiReleaseSteps = {
+    repositoryId?: string;
+    /** Only this commit's release. */
+    commit?: string;
+    limit?: number;
+    cursor?: string;
+};
 export declare function ci(t: Transport): {
     repositories: {
         /** Connect a GitHub repository for checks. Only a full key connects
@@ -320,8 +352,13 @@ export declare function ci(t: Transport): {
         /** A check with its jobs in plan order. */
         get: (id: string, options?: RequestOptions) => Promise<CiCheckDetail>;
         /** Cancel a queued or running check: its jobs end and its machines
-         * are let go. A check that has ended is answered as it is. */
-        cancel: (id: string, options?: RequestOptions) => Promise<CiCheckDetail>;
+         * are let go. A check that has ended is answered as it is; to a key
+         * that may cancel it but not read it, with its id and state alone. */
+        cancel: (id: string, options?: RequestOptions) => Promise<CiCheckDetail | CiCancelled>;
+        /** Run a check again, as GitHub's Re-run does: a new check of the
+         * same commit (a pull request's as it would land now), trusted only as
+         * the commit's last check was. A check still going is answered as it is. */
+        rerun: (id: string, options?: RequestOptions) => Promise<CiCheckDetail | CiCancelled>;
     };
     jobs: {
         /** A job with the tail of its log and the sandboxes it ran in. */
@@ -331,6 +368,11 @@ export declare function ci(t: Transport): {
         /** A repository's test files by name, with their quarantine. */
         list: (repositoryId: string, query?: ListCiTests, options?: RequestOptions) => Promise<Page<CiTest>>;
     };
+    releases: {
+        /** The steps releases took, newest first, of one repository or one
+         * commit: only repositories whose releases CI/CD runs have any. */
+        list: (query?: ListCiReleaseSteps, options?: RequestOptions) => Promise<Page<CiReleaseStep>>;
+    };
     flakes: {
         /** Flaky tests, newest first; `state: ["quarantined", "gating"]`
          * lists the open ones. */

package/dist/products/ci.js

@@ -85,12 +85,21 @@ export function ci(t) {
             /** A check with its jobs in plan order. */
             get: (id, options) => t.json({ method: "GET", path: at("/v1/ci/checks", id), ...options }),
             /** Cancel a queued or running check: its jobs end and its machines
-             * are let go. A check that has ended is answered as it is. */
+             * are let go. A check that has ended is answered as it is; to a key
+             * that may cancel it but not read it, with its id and state alone. */
             cancel: (id, options) => t.json({
                 method: "POST",
                 path: `${at("/v1/ci/checks", id)}:cancel`,
                 ...options,
             }),
+            /** Run a check again, as GitHub's Re-run does: a new check of the
+             * same commit (a pull request's as it would land now), trusted only as
+             * the commit's last check was. A check still going is answered as it is. */
+            rerun: (id, options) => t.json({
+                method: "POST",
+                path: `${at("/v1/ci/checks", id)}:rerun`,
+                ...options,
+            }),
         },
         jobs: {
             /** A job with the tail of its log and the sandboxes it ran in. */
@@ -100,6 +109,11 @@ export function ci(t) {
             /** A repository's test files by name, with their quarantine. */
             list: (repositoryId, query = {}, options) => paged("/v1/ci/tests", { ...query, repositoryId }, options),
         },
+        releases: {
+            /** The steps releases took, newest first, of one repository or one
+             * commit: only repositories whose releases CI/CD runs have any. */
+            list: (query = {}, options) => paged("/v1/ci/releases", query, options),
+        },
         flakes: {
             /** Flaky tests, newest first; `state: ["quarantined", "gating"]`
              * lists the open ones. */

package/dist/products/desktops.d.ts

@@ -0,0 +1,71 @@
+/** Desktops: a Linux desktop on its own sandbox, billed at the sandbox rates
+ * (packages/cloud/src/api/products/desktops.ts), at /v1/desktops, with a
+ * private live view and computer use: screenshot and act. In a private beta:
+ * an account outside it is refused with product_in_beta (403), and retrying
+ * does not change it. */
+import type { RequestOptions, Transport } from "../transport.js";
+import { type ResourceRecord } from "./resources.js";
+export type DesktopState = "starting" | "running" | "paused" | "stopped" | "failed" | "deleted";
+export type Desktop = ResourceRecord & {
+    name: string | null;
+    labels: Record<string, string>;
+    state: DesktopState;
+    sandboxId: string;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt: number | null;
+    memoryMiB: number;
+    vcpu: number;
+    width: number;
+    height: number;
+    timeoutSeconds: number;
+    idlePauseSeconds: number;
+    /** Opens the live desktop in a browser; carries a private preview token. */
+    liveViewUrl?: string;
+    /** When liveViewUrl's token ends; get the desktop again for a fresh one. */
+    expiresAt: string | null;
+    actions: {
+        screenshot: string;
+        act: string;
+        record: string;
+    };
+};
+export type CreateDesktop = {
+    /** 1024–16384 MiB; the server defaults to 2048. */
+    memoryMiB?: number;
+    /** The server defaults to 2 vCPU. */
+    vcpu?: number;
+    /** The screen, 640x480 to 3840x2160; 1280x800 by default. */
+    width?: number;
+    height?: number;
+    timeoutSeconds?: number;
+    idlePauseSeconds?: number;
+    name?: string;
+    labels?: Record<string, string>;
+};
+/** Only the name and labels change; a null name clears it. */
+export type UpdateDesktop = {
+    name?: string | null;
+    labels?: Record<string, string>;
+};
+/** One computer-use step, as POST /v1/desktops/{id}:act takes it. */
+export type DesktopAct = {
+    action: string;
+} & Record<string, unknown>;
+export declare function desktops(t: Transport): {
+    /** The screen as PNG (or JPEG) bytes. A write: it runs in the desktop's
+     * sandbox and wakes a paused one, so a read-only key is refused it. */
+    screenshot(id: string, shot?: {
+        format?: "png" | "jpeg";
+        quality?: number;
+    }, options?: RequestOptions): Promise<Uint8Array<ArrayBufferLike>>;
+    /** Move, click, drag, scroll, type, press keys, open a URL or launch a program. */
+    act(id: string, step: DesktopAct, options?: RequestOptions): Promise<Record<string, unknown>>;
+    base: string;
+    create: (input: CreateDesktop, options?: RequestOptions) => Promise<Desktop>;
+    get: (id: string, options?: import("./resources.js").ResourceGetOptions<"paused" | "stopped" | "starting" | "running" | "deleted" | "failed">) => Promise<Desktop>;
+    list: (query?: import("./resources.js").ResourceListQuery<"paused" | "stopped" | "starting" | "running" | "deleted" | "failed">, options?: RequestOptions) => Promise<import("../page.js").Page<Desktop>>;
+    update: (id: string, input: UpdateDesktop, options?: RequestOptions) => Promise<Desktop>;
+    wait: (id: string, target: "paused" | "stopped" | "starting" | "running" | "deleted" | "failed", options?: import("./resources.js").ResourceWaitOptions) => Promise<Desktop>;
+    delete: (id: string, options?: import("./resources.js").ResourceDeleteOptions) => Promise<Desktop>;
+};

package/dist/products/desktops.js

@@ -0,0 +1,27 @@
+import { enc, resource } from "./resources.js";
+/** A wait ends at its target or at one of these, with the desktop's error. */
+const SETTLED = ["failed", "deleted"];
+export function desktops(t) {
+    return {
+        ...resource(t, "desktops", SETTLED),
+        /** The screen as PNG (or JPEG) bytes. A write: it runs in the desktop's
+         * sandbox and wakes a paused one, so a read-only key is refused it. */
+        screenshot(id, shot = {}, options) {
+            return t.bytes({
+                method: "POST",
+                path: `/v1/desktops/${enc(id)}:screenshot`,
+                body: shot,
+                ...options,
+            });
+        },
+        /** Move, click, drag, scroll, type, press keys, open a URL or launch a program. */
+        act(id, step, options) {
+            return t.json({
+                method: "POST",
+                path: `/v1/desktops/${enc(id)}:act`,
+                body: step,
+                ...options,
+            });
+        },
+    };
+}

package/dist/products/index.d.ts

@@ -27,6 +27,8 @@ import { agents } from "./agents.js";
 import { builds } from "./builds.js";
 import { ci } from "./ci.js";
 import { containers } from "./containers.js";
+import { browsers } from "./browsers.js";
+import { desktops } from "./desktops.js";
 import { apps } from "./apps.js";
 export declare const clientExtensions: {
     images: typeof images;
@@ -54,6 +56,8 @@ export declare const clientExtensions: {
     builds: typeof builds;
     ci: typeof ci;
     containers: typeof containers;
+    browsers: typeof browsers;
+    desktops: typeof desktops;
     apps: typeof apps;
 };
 export declare const sandboxExtensions: {

package/dist/products/index.js

@@ -25,6 +25,8 @@ import { agents } from "./agents.js";
 import { builds } from "./builds.js";
 import { ci } from "./ci.js";
 import { containers } from "./containers.js";
+import { browsers } from "./browsers.js";
+import { desktops } from "./desktops.js";
 // The hub loads this file, so it loads apps.ts and resources.ts too: request
 // builders over Transport whose top level holds only types, functions and
 // imports of files the hub loads, so importing them runs nothing in the hub
@@ -73,6 +75,9 @@ export const clientExtensions = {
     // CI/CD (beta): the API answers product_in_beta outside its list.
     ci,
     containers,
+    // Browsers and Desktops (beta): the API answers product_in_beta outside its list.
+    browsers,
+    desktops,
     // A private beta (PRODUCT_BETAS): an account outside it is refused with
     // product_in_beta until Apps launches.
     apps,

package/dist/products/network.d.ts

@@ -2,9 +2,11 @@ import type { Sandbox } from "../sandbox.js";
 import type { RequestOptions, Transport } from "../transport.js";
 /** A sandbox's own network rules. */
 export type NetworkRules = {
-    /** false refuses every outbound connection. */
+    /** false refuses every outbound connection; with `allow`, everything but the
+     * list (allow-list only, stored as `internet: true` with that list). */
     internet: boolean;
-    /** When not empty, only these web destinations are reachable: `example.com`,
+    /** When not empty, only these web destinations are reachable, the internet on
+     * or off: `example.com`,
      * `*.example.com` (subdomains, not the apex), an address or a CIDR range. */
     allow?: string[];
     /** Never reachable. Wins over everything. */

package/dist/products/secrets.d.ts

@@ -171,6 +171,13 @@ export type JobSecret = {
 /** One secret by name, and where its value may go: to sandboxes through the
  * egress proxy (`sandboxes`), into scheduled jobs' environments (`jobs`), or
  * both. */
+/** A page of `secrets.list`: at most `limit` (1 to 100, default 50) secrets,
+ * by name, those named after `after`. The next page's `after` is the last
+ * name of this one; a page shorter than `limit` is the last. */
+export type ListSecrets = {
+    limit?: number;
+    after?: string;
+};
 export type SecretUse = {
     name: string;
     sandboxes: Secret | null;
@@ -219,8 +226,9 @@ export declare function secrets(t: Transport): {
         enforced: boolean;
     }>;
     /** The sandboxes' secrets: names, hosts and placeholders. Never values.
-     * `all()` includes the jobs copies. */
-    list: (options?: RequestOptions) => Promise<Secret[]>;
+     * `list({ limit, after })` gives one page, by name; `all()` includes
+     * the jobs copies. */
+    list: (query?: ListSecrets & RequestOptions) => Promise<Secret[]>;
     /** Every secret by name, with where its value may go. */
     all: (options?: RequestOptions) => Promise<SecretUse[]>;
     /** One secret by name, with where its value may go. */