withruntime 0.12.0 → 0.16.0

package/dist/products/api-keys.d.ts

@@ -0,0 +1,73 @@
+import type { RequestOptions, Transport } from "../transport.js";
+export type NewKey = {
+    /** The key's name, and its agent's: up to 80 characters. */
+    name: string;
+    /** full (the default): every action. read: every read, nothing else. */
+    access?: "full" | "read";
+    /** agent (the default): the key sees and acts on only what it makes.
+     *  account: everything in the account; only an account-wide key makes one. */
+    reach?: "agent" | "account";
+    /** The most its agent may commit in any 24 hours, or null for none. Needed
+     *  when the making key has a limit: the limits of the keys a key made add
+     *  up to at most its own. */
+    dailyLimitMicros?: number | null;
+};
+export type MadeKey = {
+    /** The key itself. Shown once: store it now. */
+    key: string;
+    keyId: string;
+    agentId: string;
+    orgId: string;
+    name: string;
+    access: "full" | "read";
+    reach: "agent" | "account";
+    dailyLimitMicros: number | null;
+    /** The making key's expiry, or null for until revoked. */
+    expires: string | null;
+    /** The id of the key that made it. */
+    madeBy: string;
+};
+export type ListedKey = {
+    keyId: string;
+    agentId: string;
+    name: string;
+    access: "full" | "read" | "selected";
+    reach: "agent" | "account";
+    dailyLimitMicros: number | null;
+    /** Committed in the last 24 hours: settled plus held, as the limit counts. */
+    dailyUsedMicros: number;
+    /** The key that made it, or null for one made on the website. */
+    madeBy: string | null;
+    createdAt: string;
+    expiresAt: string | null;
+    revokedAt: string | null;
+};
+/** One key's spend, from `GET /v1/usage?key=`. Microdollars as strings. */
+export type KeyUsage = {
+    keyId: string;
+    agentId: string;
+    name: string;
+    madeBy: string | null;
+    revokedAt: string | null;
+    dailyLimitMicros: string | null;
+    dailyUsedMicros: string;
+    spentMicros: string;
+    heldMicros: string;
+    runningSandboxes: number;
+    resources: number;
+};
+export declare function keys(t: Transport): {
+    /** Make a key with this one. It never has more than this key, and is in
+     *  the audit log as made by it. At most 100 live in an account. */
+    create: (input: NewKey, options?: RequestOptions) => Promise<MadeKey>;
+    /** This key and the keys it made (every key, for an account-wide key),
+     *  live first, with what each spent in the last 24 hours. */
+    list: (options?: RequestOptions) => Promise<ListedKey[]>;
+    /** Revoke this key or one it made: a worker's, when the worker is done. */
+    revoke: (keyId: string, options?: RequestOptions) => Promise<{
+        keyId: string;
+        revokedAt: string;
+    }>;
+    /** What one key spent: itself, or a key it made. */
+    usage: (keyId: string, options?: RequestOptions) => Promise<KeyUsage>;
+};

package/dist/products/api-keys.js

@@ -0,0 +1,23 @@
+export function keys(t) {
+    return {
+        /** Make a key with this one. It never has more than this key, and is in
+         *  the audit log as made by it. At most 100 live in an account. */
+        create: (input, options) => t.json({ method: "POST", path: "/v1/keys", body: input, ...options }),
+        /** This key and the keys it made (every key, for an account-wide key),
+         *  live first, with what each spent in the last 24 hours. */
+        list: async (options) => (await t.json({ method: "GET", path: "/v1/keys", ...options })).keys,
+        /** Revoke this key or one it made: a worker's, when the worker is done. */
+        revoke: (keyId, options) => t.json({
+            method: "DELETE",
+            path: `/v1/keys/${encodeURIComponent(keyId)}`,
+            ...options,
+        }),
+        /** What one key spent: itself, or a key it made. */
+        usage: async (keyId, options) => (await t.json({
+            method: "GET",
+            path: "/v1/usage",
+            query: { key: keyId },
+            ...options,
+        })).key,
+    };
+}

package/dist/products/apps.d.ts

@@ -1,5 +1,5 @@
-import { Page } from "../page.js";
 import type { RequestOptions, Transport } from "../transport.js";
+import { type ResourceDeleteOptions, type ResourceGetOptions, type ResourceListQuery, type ResourceWaitOptions } from "./resources.js";
 /** Private until launch. A deployment's completion follows its own record,
  * not the app's state. */
 export type AppState = "waiting" | "live" | "failed" | "deleting" | "deleted";
@@ -112,36 +112,17 @@ export type DeployGetOptions = RequestOptions & {
     waitFor?: DeployState;
     timeoutSeconds?: number;
 };
-export type AppListQuery = {
-    name?: string;
-    /** Repeated key:value filters; all must match. */
-    label?: readonly string[];
-    /** Defaults to waiting, live and failed. */
-    state?: readonly AppState[];
-    /** 1 to 100; defaults to 50. */
-    limit?: number;
-    cursor?: string;
-};
-export type AppGetOptions = RequestOptions & {
-    waitFor?: AppState;
-    /** Server wait, 1 to 60 seconds; defaults to 30. Check the returned state. */
-    timeoutSeconds?: number;
-};
-export type AppWaitOptions = RequestOptions & {
-    /** Whole wait, including retries; defaults to 300000 ms. 0 disables it. */
-    timeoutMs?: number;
-    /** Delay between reads; defaults to 250 ms. */
-    pollMs?: number;
-};
-export type AppDeleteOptions = AppWaitOptions & {
-    wait?: boolean;
-};
+/** Defaults to waiting, live and failed. */
+export type AppListQuery = ResourceListQuery<AppState>;
+export type AppGetOptions = ResourceGetOptions<AppState>;
+export type AppWaitOptions = ResourceWaitOptions;
+export type AppDeleteOptions = ResourceDeleteOptions;
 export declare function apps(t: Transport): {
     /** Create a resource waiting for its first version. Defaults belong to
      * the API, so the SDK does not override them. */
     create: (input: CreateApp, options?: RequestOptions) => Promise<App>;
-    get: (id: string, options?: AppGetOptions) => Promise<App>;
-    list: (query?: AppListQuery, options?: RequestOptions) => Promise<Page<App>>;
+    get: (id: string, options?: ResourceGetOptions<AppState>) => Promise<App>;
+    list: (query?: ResourceListQuery<AppState>, options?: RequestOptions) => Promise<import("../page.js").Page<App>>;
     deploy: (id: string, input: DeployApp, options?: AppWaitOptions) => Promise<AppDeploy>;
     getDeploy: (id: string, deployId: string, options?: DeployGetOptions) => Promise<AppDeploy>;
     /** Resume by deploy id after a process restart, without creating another version. */
@@ -153,14 +134,14 @@ export declare function apps(t: Transport): {
     /** Follow resource state, not a deployment: an
      * older live version can survive a failed rollout of a newer version. */
     wait: (id: string, target: "live" | "deleted", options?: AppWaitOptions) => Promise<App>;
-    delete: (id: string, options?: AppDeleteOptions) => Promise<App>;
+    delete: (id: string, options?: ResourceDeleteOptions) => Promise<App>;
 };
 export declare function functions(t: Transport): {
     /** Create a resource waiting for its first version. Defaults belong to
      * the API, so the SDK does not override them. */
     create: (input: CreateFunction, options?: RequestOptions) => Promise<RuntimeFunction>;
-    get: (id: string, options?: AppGetOptions) => Promise<RuntimeFunction>;
-    list: (query?: AppListQuery, options?: RequestOptions) => Promise<Page<RuntimeFunction>>;
+    get: (id: string, options?: ResourceGetOptions<AppState>) => Promise<RuntimeFunction>;
+    list: (query?: ResourceListQuery<AppState>, options?: RequestOptions) => Promise<import("../page.js").Page<RuntimeFunction>>;
     deploy: (id: string, input: DeployApp, options?: AppWaitOptions) => Promise<AppDeploy>;
     getDeploy: (id: string, deployId: string, options?: DeployGetOptions) => Promise<AppDeploy>;
     /** Resume by deploy id after a process restart, without creating another version. */
@@ -172,5 +153,5 @@ export declare function functions(t: Transport): {
     /** Follow resource state, not a deployment: an
      * older live version can survive a failed rollout of a newer version. */
     wait: (id: string, target: "live" | "deleted", options?: AppWaitOptions) => Promise<RuntimeFunction>;
-    delete: (id: string, options?: AppDeleteOptions) => Promise<RuntimeFunction>;
+    delete: (id: string, options?: ResourceDeleteOptions) => Promise<RuntimeFunction>;
 };

package/dist/products/apps.js

@@ -1,106 +1,7 @@
-import { RuntimeError } from "../errors.js";
-import { Page } from "../page.js";
-import { pause } from "../wait.js";
-const enc = encodeURIComponent;
-function invalid(field) {
-    return new RuntimeError({
-        code: "invalid_request",
-        status: 0,
-        message: `${field} must be a finite, nonnegative number.`,
-        hint: "Fix the option and call again; nothing was sent.",
-        details: { field },
-    });
-}
-/** One deadline covers the write, retries and every read. A timed-out delete
- * can be retried after a process restart with this same key. */
-async function following(options, work) {
-    const { pollMs = 250, timeoutMs = 300_000, signal, ...rest } = options;
-    if (!Number.isFinite(pollMs) || pollMs < 0)
-        throw invalid("pollMs");
-    if (!Number.isFinite(timeoutMs) || timeoutMs < 0)
-        throw invalid("timeoutMs");
-    const deadline = new AbortController();
-    const combined = signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal;
-    const timer = timeoutMs > 0 ? setTimeout(() => deadline.abort(), timeoutMs) : undefined;
-    const request = { ...rest, timeoutMs: 0, signal: combined };
-    const poll = () => pause(pollMs, combined);
-    try {
-        combined.throwIfAborted();
-        const result = await work(request, poll);
-        combined.throwIfAborted();
-        return result;
-    }
-    catch (cause) {
-        if (!combined.aborted) {
-            // A read failure still belongs to the write that started this wait.
-            // Keep its key so a caller can recover after losing the reply.
-            if (cause instanceof RuntimeError && rest.idempotencyKey && !cause.idempotencyKey)
-                throw new RuntimeError({
-                    message: cause.message,
-                    code: cause.code,
-                    status: cause.status,
-                    requestId: cause.requestId,
-                    hint: cause.hint,
-                    details: cause.details,
-                    retryAfterMs: cause.retryAfterMs,
-                    idempotencyKey: rest.idempotencyKey,
-                    cause,
-                });
-            throw cause;
-        }
-        throw new RuntimeError({
-            code: "timeout",
-            status: 0,
-            message: "Waiting was cancelled or reached its deadline; the resource may still change.",
-            hint: "Read the resource to resume waiting. Retry a write with the same idempotencyKey.",
-            ...(rest.idempotencyKey === undefined ? {} : { idempotencyKey: rest.idempotencyKey }),
-            cause,
-        });
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
+import { enc, following, resource, } from "./resources.js";
 function copies(t, plural) {
-    const base = `/v1/${plural}`;
-    const get = (id, options = {}) => {
-        const { waitFor, timeoutSeconds, ...request } = options;
-        return t.json({
-            method: "GET",
-            path: `${base}/${enc(id)}`,
-            query: { waitFor, timeoutSeconds },
-            ...request,
-        });
-    };
-    const list = async (query = {}, options) => {
-        const page = await t.json({
-            method: "GET",
-            path: base,
-            query,
-            ...options,
-        });
-        return new Page(page.data, page.nextCursor, (cursor) => list({ ...query, cursor }, options));
-    };
-    const follow = async (id, target, request, pause, initial) => {
-        let record = initial ?? (await get(id, request));
-        for (;;) {
-            if (record.state === target)
-                return record;
-            if (["failed", "deleted", "live"].includes(record.state))
-                throw new RuntimeError({
-                    code: record.error?.code ?? "unexpected_state",
-                    status: 0,
-                    message: record.error?.message ?? `Expected ${target}, but ${id} reached ${record.state}.`,
-                    hint: "Read the resource and inspect its error before starting another change.",
-                    details: { id, state: record.state, target, resource: record },
-                    ...(request.idempotencyKey === undefined
-                        ? {}
-                        : { idempotencyKey: request.idempotencyKey }),
-                });
-            await pause();
-            record = await get(id, request);
-        }
-    };
+    const shape = resource(t, plural, ["failed", "deleted", "live"]);
+    const { base, get } = shape;
     const getDeploy = (id, deployId, options = {}) => {
         const { waitFor, timeoutSeconds, ...request } = options;
         return t.json({
@@ -128,9 +29,9 @@ function copies(t, plural) {
     return {
         /** Create a resource waiting for its first version. Defaults belong to
          * the API, so the SDK does not override them. */
-        create: (input, options) => t.json({ method: "POST", path: base, body: input, ...options }),
+        create: shape.create,
         get,
-        list,
+        list: shape.list,
         deploy: (id, input, options = {}) => {
             const { wait = false, ...body } = input;
             return writeDeploy(id, "deploys", body, wait, options);
@@ -144,17 +45,11 @@ function copies(t, plural) {
         },
         versions: (id, options) => t.json({ method: "GET", path: `${base}/${enc(id)}/versions`, ...options }),
         copies: (id, options) => t.json({ method: "GET", path: `${base}/${enc(id)}/copies`, ...options }),
-        update: (id, input, options) => t.json({ method: "POST", path: `${base}/${enc(id)}:update`, body: input, ...options }),
+        update: shape.update,
         /** Follow resource state, not a deployment: an
          * older live version can survive a failed rollout of a newer version. */
-        wait: (id, target, options = {}) => following(options, (request, pause) => follow(id, target, request, pause)),
-        delete: (id, options = {}) => {
-            const { wait = false, pollMs, ...request } = options;
-            const remove = (rest) => t.json({ method: "DELETE", path: `${base}/${enc(id)}`, ...rest });
-            if (!wait)
-                return remove(request);
-            return following({ ...request, pollMs, idempotencyKey: request.idempotencyKey ?? crypto.randomUUID() }, async (rest, pause) => follow(id, "deleted", rest, pause, await remove(rest)));
-        },
+        wait: (id, target, options = {}) => shape.wait(id, target, options),
+        delete: shape.delete,
     };
 }
 export function apps(t) {

package/dist/products/balancers.d.ts

@@ -0,0 +1,87 @@
+import type { Transport } from "../transport.js";
+import { type ResourceRecord } from "./resources.js";
+/** Private until launch: load balancers and the inbound firewall
+ * (packages/cloud/src/api/products/balancers.ts). A change answers
+ * `applying`; it is `active` once every router serves it, and `waitingOn`
+ * names any router that does not yet. */
+export type AddressState = "applying" | "active" | "failed" | "deleting" | "deleted";
+type Common = ResourceRecord & {
+    name: string | null;
+    labels: Record<string, string>;
+    state: AddressState;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt: number | null;
+    /** Routers that do not yet serve the newest change. */
+    waitingOn: string[];
+};
+/** A sandbox with the port it serves on, or an App or Function by id. */
+export type BalancerTarget = {
+    id: string;
+    port?: number;
+};
+export type Balancer = Common & {
+    hostname: string;
+    targets: BalancerTarget[];
+};
+export type CreateBalancer = {
+    name?: string;
+    labels?: Record<string, string>;
+    /** Up to 1000, all the organization's own. */
+    targets?: BalancerTarget[];
+};
+export type UpdateBalancer = {
+    name?: string | null;
+    labels?: Record<string, string>;
+    /** Replaces the whole list. */
+    targets?: BalancerTarget[];
+};
+export type FirewallRule = Common & {
+    address: string;
+    effect: "allow" | "deny" | "limit";
+    source?: string;
+    ports?: string;
+    requests?: number;
+    seconds?: number;
+    burst?: number;
+    priority: number;
+};
+export type CreateFirewallRule = {
+    name?: string;
+    labels?: Record<string, string>;
+    /** The load balancer it guards. */
+    address: string;
+    priority?: number;
+} & ({
+    effect: "allow" | "deny";
+    source?: string;
+    ports?: string;
+} | {
+    effect: "limit";
+    requests: number;
+    seconds: number;
+    burst?: number;
+});
+export type UpdateFirewallRule = {
+    name?: string | null;
+    labels?: Record<string, string>;
+};
+export declare function balancers(t: Transport): {
+    base: string;
+    create: (input: CreateBalancer, options?: import("../transport.js").RequestOptions) => Promise<Balancer>;
+    get: (id: string, options?: import("./resources.js").ResourceGetOptions<"active" | "deleted" | "failed" | "deleting" | "applying">) => Promise<Balancer>;
+    list: (query?: import("./resources.js").ResourceListQuery<"active" | "deleted" | "failed" | "deleting" | "applying">, options?: import("../transport.js").RequestOptions) => Promise<import("../page.js").Page<Balancer>>;
+    update: (id: string, input: UpdateBalancer, options?: import("../transport.js").RequestOptions) => Promise<Balancer>;
+    wait: (id: string, target: "active" | "deleted" | "failed" | "deleting" | "applying", options?: import("./resources.js").ResourceWaitOptions) => Promise<Balancer>;
+    delete: (id: string, options?: import("./resources.js").ResourceDeleteOptions) => Promise<Balancer>;
+};
+export declare function firewall(t: Transport): {
+    base: string;
+    create: (input: CreateFirewallRule, options?: import("../transport.js").RequestOptions) => Promise<FirewallRule>;
+    get: (id: string, options?: import("./resources.js").ResourceGetOptions<"active" | "deleted" | "failed" | "deleting" | "applying">) => Promise<FirewallRule>;
+    list: (query?: import("./resources.js").ResourceListQuery<"active" | "deleted" | "failed" | "deleting" | "applying">, options?: import("../transport.js").RequestOptions) => Promise<import("../page.js").Page<FirewallRule>>;
+    update: (id: string, input: UpdateFirewallRule, options?: import("../transport.js").RequestOptions) => Promise<FirewallRule>;
+    wait: (id: string, target: "active" | "deleted" | "failed" | "deleting" | "applying", options?: import("./resources.js").ResourceWaitOptions) => Promise<FirewallRule>;
+    delete: (id: string, options?: import("./resources.js").ResourceDeleteOptions) => Promise<FirewallRule>;
+};
+export {};

package/dist/products/balancers.js

@@ -0,0 +1,8 @@
+import { resource } from "./resources.js";
+const SETTLED = ["failed", "deleted"];
+export function balancers(t) {
+    return resource(t, "balancers", SETTLED);
+}
+export function firewall(t) {
+    return resource(t, "firewall/rules", SETTLED);
+}

package/dist/products/builds.d.ts

@@ -16,16 +16,33 @@ type Resource = {
 export type Build = Resource & {
     repositoryId: string;
     ref: string;
+    /** The branch whose move asked for it, when the caller said. */
+    branch: string | null;
     commit: string | null;
     state: BuildState;
     reason: string | null;
+    /** Milliseconds per step once the runner is done (install, build, mirror,
+     * fork, snapshot, total, ...); null until then. */
+    timings: Record<string, number> | null;
+    /** The saved server an App deploys, once a build of a repository with a
+     * start command succeeded; null otherwise. */
+    outputSnapshotId: string | null;
 };
 export type CreateBuild = {
     repositoryId: string;
     ref: string;
+    /** The same branch and commit is one build; a newer build of the branch
+     * supersedes older ones not yet ended. */
+    branch?: string;
     name?: string;
     labels?: Record<string, string>;
 };
+/** A connected repository's settings changed in place; its id and builds
+ * stay. A field left out stays as it is; a null name clears it. */
+export type ChangeRepository = Partial<Omit<ConnectRepository, "provider" | "name" | "labels">> & {
+    name?: string | null;
+    labels?: Record<string, string>;
+};
 export type ConnectRepository = {
     provider: "github" | "git";
     repository: string;
@@ -37,6 +54,14 @@ export type ConnectRepository = {
     /** Leave out to choose by the lockfile (bun, pnpm, Yarn or npm). */
     installCommand?: string | null;
     buildCommand?: string | null;
+    /** Run after the build with PORT set; the build ends as this server,
+     * answering healthPath with 200 and saved with its memory. */
+    startCommand?: string | null;
+    port?: number;
+    healthPath?: string | null;
+    /** Settings install and build are given. Never a secret: anyone who reads
+     * the repository sees them. */
+    buildEnv?: Record<string, string>;
     name?: string;
     labels?: Record<string, string>;
 };
@@ -49,6 +74,10 @@ export type Repository = Resource & {
     rootDirectory: string;
     installCommand: string | null;
     buildCommand: string | null;
+    startCommand: string | null;
+    port: number;
+    healthPath: string | null;
+    buildEnv: Record<string, string>;
     state: "connected" | "disconnected";
 };
 export type ListBuilds = {
@@ -120,6 +149,7 @@ export declare function builds(t: Transport): {
     repositories: {
         connect: (input: ConnectRepository, options?: RequestOptions) => Promise<Repository>;
         list: (query?: ListRepositories, options?: RequestOptions) => Promise<Page<Repository>>;
+        update: (id: string, change: ChangeRepository, options?: RequestOptions) => Promise<Repository>;
         disconnect: (id: string, options?: RequestOptions) => Promise<Repository>;
     };
 };

package/dist/products/builds.js

@@ -211,6 +211,12 @@ export function builds(t) {
         repositories: {
             connect: (input, options) => t.json({ method: "POST", path: "/v1/repositories", body: input, ...options }),
             list: listRepositories,
+            update: (id, change, options) => t.json({
+                method: "POST",
+                path: `/v1/repositories/${encodeURIComponent(id)}:update`,
+                body: change,
+                ...options,
+            }),
             disconnect: (id, options) => t.json({
                 method: "DELETE",
                 path: `/v1/repositories/${encodeURIComponent(id)}`,

package/dist/products/index.d.ts

@@ -13,6 +13,7 @@ import { audit } from "./audit.js";
 import { sso } from "./sso.js";
 import { switching } from "./switching.js";
 import { limits } from "./limits.js";
+import { keys } from "./api-keys.js";
 import { volumes } from "./volumes.js";
 import { jobs } from "./jobs.js";
 import { sandboxMounts } from "./mounts.js";
@@ -27,6 +28,7 @@ export declare const clientExtensions: {
     referrals: typeof referrals;
     billing: typeof billing;
     limits: typeof limits;
+    keys: typeof keys;
     switching: typeof switching;
     secrets: typeof secrets;
     webhooks: typeof webhooks;

package/dist/products/index.js

@@ -11,6 +11,7 @@ import { audit } from "./audit.js";
 import { sso } from "./sso.js";
 import { switching } from "./switching.js";
 import { limits } from "./limits.js";
+import { keys } from "./api-keys.js";
 import { volumes } from "./volumes.js";
 import { jobs } from "./jobs.js";
 import { sandboxMounts } from "./mounts.js";
@@ -40,6 +41,7 @@ export const clientExtensions = {
     referrals,
     billing,
     limits,
+    keys,
     switching,
     secrets,
     webhooks,

package/dist/products/jobs.d.ts

@@ -1,7 +1,7 @@
 import { Page } from "../page.js";
 import type { RequestOptions, Transport } from "../transport.js";
 /** A run's sandbox. Every field has a default; a run is a sandbox of this
- * size, on the included usage first and then on credit at the sandbox rates. */
+ * size, on the free usage first and then on credit at the sandbox rates. */
 export type JobCompute = {
     region: string;
     vcpu: number;
@@ -176,7 +176,7 @@ export declare function jobBody(input: CreateJob): Record<string, unknown>;
  * request id, and says no retry will change it. */
 export declare function switchedOff(product: string): (error: unknown) => never;
 /** Scheduled jobs: a command run in a fresh sandbox, once or on a cron
- * schedule. Each run is a sandbox, paid for as one: from the included usage first while the run fits the limits without credit, then from credit
+ * schedule. Each run is a sandbox, paid for as one: from the free usage first while the run fits the limits without credit, then from credit
  * at the sandbox rates, through the same holds and spending limits.
  *
  *   const job = await runtime.jobs.create({

package/dist/products/jobs.js

@@ -131,7 +131,7 @@ export function switchedOff(product) {
     };
 }
 /** Scheduled jobs: a command run in a fresh sandbox, once or on a cron
- * schedule. Each run is a sandbox, paid for as one: from the included usage first while the run fits the limits without credit, then from credit
+ * schedule. Each run is a sandbox, paid for as one: from the free usage first while the run fits the limits without credit, then from credit
  * at the sandbox rates, through the same holds and spending limits.
  *
  *   const job = await runtime.jobs.create({

package/dist/products/limits.d.ts

@@ -18,9 +18,23 @@ export type KeyLimits = {
     /** Machine time the account can still run without credit, the same
      * figures as `usage.get()`'s `trial`, or null when it has none. */
     trial: Usage["trial"];
+    /** Every limit the account is held to, with what it uses of each now: the
+     * numbers a create past one is refused `quota_exceeded` by (its
+     * `details.limit` names the row). Null when they can't be read. */
+    account: AccountLimit[] | null;
 };
-/** `runtime.limits.get()`: whether this key is read-only, and what its agent
- * may still spend today. An owner sets the limit at
+/** One of the account's limits, as https://withruntime.com/account/limits shows it. */
+export type AccountLimit = {
+    /** `<kind>.<dimension>`: sandbox.count, sandbox.vcpu, sandbox.memory_mib, volume.count… */
+    limit: string;
+    label: string;
+    /** What `max` and `used` count: things, or MiB. */
+    unit: "count" | "mib";
+    max: number;
+    used: number;
+};
+/** `runtime.limits.get()`: whether this key is read-only, what its agent
+ * may still spend today, and the account's limits with what it uses of each. An owner sets the limit at
  * https://withruntime.com/account/keys; a key can read it, never change it.
  * Past it, a create, wake, extension or renewal fails with
  * `spending_limit_reached` (HTTP 402). */

package/dist/products/limits.js

@@ -1,5 +1,5 @@
-/** `runtime.limits.get()`: whether this key is read-only, and what its agent
- * may still spend today. An owner sets the limit at
+/** `runtime.limits.get()`: whether this key is read-only, what its agent
+ * may still spend today, and the account's limits with what it uses of each. An owner sets the limit at
  * https://withruntime.com/account/keys; a key can read it, never change it.
  * Past it, a create, wake, extension or renewal fails with
  * `spending_limit_reached` (HTTP 402). */

package/dist/products/mcp.d.ts

@@ -38,6 +38,8 @@ export type McpServerRequest = {
 export type McpGateway = {
     running: boolean;
     port: number | null;
+    /** The URLs are a public preview: no link token, no expiry. */
+    public?: boolean;
     /** Send it as `Authorization: Bearer <token>`. */
     token?: string | null;
     headers?: Record<string, string>;
@@ -65,6 +67,9 @@ export declare function sandboxMcp(t: Transport, sandbox: Sandbox): {
     start: (servers: McpServerRequest[], input?: {
         port?: number;
         replace?: boolean;
+        /** URLs that never expire, guarded by the header alone, which is kept
+         * across starts until `stop()`. Paid accounts only. */
+        public?: boolean;
     }, options?: RequestOptions) => Promise<McpGateway>;
     /** Their state, and fresh URLs. */
     get: (options?: RequestOptions) => Promise<McpGateway>;