withruntime 0.11.2 → 0.14.0

package/dist/product-renames.d.ts

@@ -0,0 +1,103 @@
+/** CLOUD.md section 4: an old product word keeps working for ALIAS_DAYS after
+ * its rename ships, with a warning naming the new word, and then fails with
+ * `name_retired` and a hint. One implementation for the API's paths, the MCP's
+ * tool names, the CLI's commands and the SDK's properties; each reads the table in
+ * product-names.ts. This file imports nothing else, so the CLI can carry it. */
+import { type ProductName } from "./product-names.js";
+export type Surface = "api" | "mcp" | "cli" | "sdk";
+export type RetiredName = {
+    readonly code: "name_retired";
+    readonly status: 410;
+    readonly message: string;
+    readonly hint: string;
+};
+export type RenamedField = {
+    readonly name: "pot" | "potLimits";
+    readonly now: "startupIncluded" | "startupLimits";
+    readonly where: "GET /v1/usage";
+    readonly retires: string | null;
+};
+/** Response fields follow the same 30-day rule as product names. */
+export declare const RENAMED_FIELDS: readonly RenamedField[];
+/** CLOUD.md section 4: warn while a response field's old name works, then
+ * fail with the same code, status and hint as a retired product name. */
+export declare function fieldUse(name: RenamedField["name"], now?: Date, table?: readonly RenamedField[]): {
+    kind: "renamed";
+    warning: string;
+} | {
+    kind: "retired";
+    error: RetiredName;
+};
+export type NameUse = 
+/** The product's own word, or in the CLI its singular shortcut. */
+{
+    readonly kind: "current";
+    readonly product: ProductName;
+}
+/** An old word, still served: say `warning` to the caller. */
+ | {
+    readonly kind: "renamed";
+    readonly product: ProductName;
+    readonly old: string;
+    /** The new words, `networks/wireguard` for `tunnel`. */
+    readonly to: string;
+    readonly retires: string | null;
+    readonly warning: string;
+}
+/** An old word past its date. */
+ | {
+    readonly kind: "retired";
+    readonly product: ProductName;
+    readonly old: string;
+    readonly to: string;
+    readonly error: RetiredName;
+};
+/** The new words for an old one: the product, then where inside it. */
+export declare function newWords(product: string, under?: string): string;
+/** The property path of product words in the JavaScript SDK:
+ * `networks/wireguard` is `networks.wireguard`, `web-analytics` is
+ * `webAnalytics`. */
+export declare function sdkPath(words: string): string[];
+/** Whether `retires` (a UTC date) has come at `now`. */
+export declare function isRetired(retires: string | null, now: Date): boolean;
+/** What one word means on one surface at `now`, or undefined when it names no
+ * product. The CLI takes a product's singular silently, unless the word is
+ * still another product's live old name (`tunnel` names the private network
+ * until it retires, then incoming tunnels). */
+export declare function resolveWord(word: string, surface: Surface, now?: Date, table?: readonly ProductName[]): NameUse | undefined;
+/** An API path under an old word, rewritten to the new one: `/v1/addresses/x`
+ * is `/v1/ips/x`. Undefined when the path's first word is not an old name. */
+export declare function renamePath(pathname: string, now?: Date, table?: readonly ProductName[]): {
+    readonly path: string;
+    readonly use: Exclude<NameUse, {
+        kind: "current";
+    }>;
+} | undefined;
+/** An MCP tool under an old word, renamed: `runtime_sandbox_exec` is
+ * `runtime_sandboxes_exec`. The longest old word wins, so `runtime_web_x`
+ * never takes a shorter old name's place. */
+export declare function renameTool(tool: string, now?: Date, table?: readonly ProductName[]): {
+    readonly tool: string;
+    readonly use: Exclude<NameUse, {
+        kind: "current";
+    }>;
+} | undefined;
+/** The headers an answer under an old path carries: `Deprecation` (RFC 9745)
+ * from the day the rename shipped, `Sunset` (RFC 8594) on the day it stops,
+ * a `Link` to the new path, and `Warning` with the sentence the SDK and CLI
+ * print. */
+export declare function renamedHeaders(renamed: {
+    readonly path: string;
+    readonly use: NameUse;
+}): Record<string, string>;
+/** The sentence inside a `Warning: 299` header, for the SDK and CLI to print;
+ * undefined for any other header. */
+export declare function warningText(header: string | null): string | undefined;
+/** A CLI command line's product words, in their plural form: `sandbox ls` is
+ * `sandboxes ls` silently, and `tunnel create` is `networks wireguard create`
+ * with the warning to print. Undefined when the first word names no product,
+ * so a top-level command (`login`, `ls`) passes through. */
+export declare function cliWords(args: readonly string[], now?: Date, table?: readonly ProductName[]): {
+    readonly args: string[];
+    readonly use: NameUse;
+} | undefined;

package/dist/product-renames.js

@@ -0,0 +1,189 @@
+/** CLOUD.md section 4: an old product word keeps working for ALIAS_DAYS after
+ * its rename ships, with a warning naming the new word, and then fails with
+ * `name_retired` and a hint. One implementation for the API's paths, the MCP's
+ * tool names, the CLI's commands and the SDK's properties; each reads the table in
+ * product-names.ts. This file imports nothing else, so the CLI can carry it. */
+import { ALIAS_DAYS, PRODUCT_NAMES, wordOf } from "./product-names.js";
+/** CLOUD.md section 4: the deploy shipping this batch sets its retirement
+ * date to the deploy day plus ALIAS_DAYS, as product-names.ts does. */
+const RENAME_OF_8_OCTOBER = null;
+/** Response fields follow the same 30-day rule as product names. */
+export const RENAMED_FIELDS = [
+    { name: "pot", now: "startupIncluded", where: "GET /v1/usage", retires: RENAME_OF_8_OCTOBER },
+    { name: "potLimits", now: "startupLimits", where: "GET /v1/usage", retires: RENAME_OF_8_OCTOBER },
+];
+/** CLOUD.md section 4: warn while a response field's old name works, then
+ * fail with the same code, status and hint as a retired product name. */
+export function fieldUse(name, now = new Date(), table = RENAMED_FIELDS) {
+    const field = table.find((field) => field.name === name);
+    if (!field)
+        throw new Error(`Unknown renamed response field: ${name}`);
+    const from = `usage.${field.name}`;
+    const to = `usage.${field.now}`;
+    if (isRetired(field.retires, now))
+        return {
+            kind: "retired",
+            error: {
+                code: RETIRED[0],
+                status: RETIRED[1],
+                message: `${from} was renamed ${to} and stopped working on ${field.retires}.`,
+                hint: `Use ${to}.`,
+            },
+        };
+    const by = field.retires === null ? "" : ` It stops working on ${field.retires}.`;
+    return { kind: "renamed", warning: `${from} is now ${to}.${by}` };
+}
+/** The new words for an old one: the product, then where inside it. */
+export function newWords(product, under) {
+    return under === undefined ? product : `${product}/${under}`;
+}
+/** How each surface writes product words (`networks/wireguard`), for
+ * messages. */
+function spelled(words, surface) {
+    if (surface === "api")
+        return `/v1/${words}`;
+    if (surface === "mcp")
+        return `runtime_${words.replaceAll(/[-/]/g, "_")}`;
+    if (surface === "sdk")
+        return `runtime.${sdkPath(words).join(".")}`;
+    return `runtime ${words.replaceAll("/", " ")}`;
+}
+/** The property path of product words in the JavaScript SDK:
+ * `networks/wireguard` is `networks.wireguard`, `web-analytics` is
+ * `webAnalytics`. */
+export function sdkPath(words) {
+    return words
+        .split("/")
+        .map((word) => word.replaceAll(/[-_]([a-z])/g, (_, c) => c.toUpperCase()));
+}
+/** Whether `retires` (a UTC date) has come at `now`. */
+export function isRetired(retires, now) {
+    return retires !== null && now.getTime() >= Date.parse(`${retires}T00:00:00Z`);
+}
+/** The code and status of an old word after its date (api.md's table). */
+const RETIRED = ["name_retired", 410];
+/** What one word means on one surface at `now`, or undefined when it names no
+ * product. The CLI takes a product's singular silently, unless the word is
+ * still another product's live old name (`tunnel` names the private network
+ * until it retires, then incoming tunnels). */
+export function resolveWord(word, surface, now = new Date(), table = PRODUCT_NAMES) {
+    const asked = wordOf(word);
+    const own = table.find((product) => product.name === asked);
+    if (own)
+        return { kind: "current", product: own };
+    let retired;
+    for (const product of table) {
+        for (const old of product.old) {
+            if (wordOf(old.name) !== asked)
+                continue;
+            if (surface === "cli" && product.singular === asked)
+                return { kind: "current", product };
+            const to = newWords(product.name, old.under);
+            const target = spelled(to, surface);
+            if (!isRetired(old.retires, now)) {
+                const by = old.retires === null ? "" : ` It stops working on ${old.retires}.`;
+                return {
+                    kind: "renamed",
+                    product,
+                    old: asked,
+                    to,
+                    retires: old.retires,
+                    warning: `${spelled(asked, surface)} is now ${target}.${by}`,
+                };
+            }
+            retired = {
+                kind: "retired",
+                product,
+                old: asked,
+                to,
+                error: {
+                    code: RETIRED[0],
+                    status: RETIRED[1],
+                    message: `${spelled(asked, surface)} was renamed ${target} and stopped working on ${old.retires}.`,
+                    hint: `Use ${target}.`,
+                },
+            };
+        }
+    }
+    if (surface === "cli") {
+        const shortcut = table.find((product) => product.singular === asked);
+        if (shortcut)
+            return { kind: "current", product: shortcut };
+    }
+    return retired;
+}
+/** An API path under an old word, rewritten to the new one: `/v1/addresses/x`
+ * is `/v1/ips/x`. Undefined when the path's first word is not an old name. */
+export function renamePath(pathname, now = new Date(), table = PRODUCT_NAMES) {
+    const found = /^\/v1\/([a-z][a-z0-9_-]*)(?=\/|:|$)/.exec(pathname);
+    if (!found)
+        return undefined;
+    const use = resolveWord(found[1], "api", now, table);
+    if (!use || use.kind === "current")
+        return undefined;
+    return { path: `/v1/${use.to}${pathname.slice(found[0].length)}`, use };
+}
+/** An MCP tool under an old word, renamed: `runtime_sandbox_exec` is
+ * `runtime_sandboxes_exec`. The longest old word wins, so `runtime_web_x`
+ * never takes a shorter old name's place. */
+export function renameTool(tool, now = new Date(), table = PRODUCT_NAMES) {
+    if (!tool.startsWith("runtime_"))
+        return undefined;
+    const rest = tool.slice("runtime_".length);
+    let best;
+    for (const product of table) {
+        for (const old of product.old) {
+            const word = wordOf(old.name).replaceAll("-", "_");
+            if (rest !== word && !rest.startsWith(`${word}_`))
+                continue;
+            if (best && best.word.length >= word.length)
+                continue;
+            const use = resolveWord(word, "mcp", now, table);
+            if (use && use.kind !== "current")
+                best = { word, use };
+        }
+    }
+    if (!best)
+        return undefined;
+    const renamed = `${spelled(best.use.to, "mcp")}${rest.slice(best.word.length)}`;
+    return { tool: renamed, use: best.use };
+}
+/** The headers an answer under an old path carries: `Deprecation` (RFC 9745)
+ * from the day the rename shipped, `Sunset` (RFC 8594) on the day it stops,
+ * a `Link` to the new path, and `Warning` with the sentence the SDK and CLI
+ * print. */
+export function renamedHeaders(renamed) {
+    const { use } = renamed;
+    if (use.kind !== "renamed")
+        return {};
+    const headers = {
+        warning: `299 runtime "${use.warning.replaceAll('"', "'")}"`,
+        link: `<${renamed.path}>; rel="successor-version"`,
+    };
+    if (use.retires !== null) {
+        const ends = Date.parse(`${use.retires}T00:00:00Z`);
+        headers.deprecation = `@${Math.floor((ends - ALIAS_DAYS * 86_400_000) / 1000)}`;
+        headers.sunset = new Date(ends).toUTCString();
+    }
+    return headers;
+}
+/** The sentence inside a `Warning: 299` header, for the SDK and CLI to print;
+ * undefined for any other header. */
+export function warningText(header) {
+    const found = header === null ? null : /^299 \S+ "(.*)"$/.exec(header);
+    return found ? found[1] : undefined;
+}
+/** A CLI command line's product words, in their plural form: `sandbox ls` is
+ * `sandboxes ls` silently, and `tunnel create` is `networks wireguard create`
+ * with the warning to print. Undefined when the first word names no product,
+ * so a top-level command (`login`, `ls`) passes through. */
+export function cliWords(args, now = new Date(), table = PRODUCT_NAMES) {
+    const [first, ...rest] = args;
+    if (first === undefined)
+        return undefined;
+    const use = resolveWord(first, "cli", now, table);
+    if (!use)
+        return undefined;
+    const words = use.kind === "current" ? use.product.name : use.to;
+    return { args: [...words.split("/"), ...rest], use };
+}

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

@@ -0,0 +1,157 @@
+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";
+export type AppSettings = {
+    minCopies: number;
+    maxCopies: number;
+    concurrency: number;
+    spares: number;
+    vcpu: number;
+    memoryMiB: number;
+    port: number;
+    healthPath?: string;
+};
+export type App = AppSettings & {
+    id: string;
+    name: string | null;
+    labels: Record<string, string>;
+    state: AppState;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt: number | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+    liveVersion: number | null;
+    previousVersion: number | null;
+};
+export type RuntimeFunction = Omit<App, "minCopies"> & {
+    minCopies: 0;
+};
+export type CreateFunction = {
+    /** Up to 128 letters, digits, dots, dashes or underscores; alphanumeric first. */
+    name?: string;
+    /** At most 32 entries, each value at most 256 characters. */
+    labels?: Record<string, string>;
+    /** Required, 1 to 1000. Bounds the number of awake copies. */
+    maxCopies: number;
+    /** Required, 1 to 16. */
+    vcpu: number;
+    /** Required, 128 to 65536 MiB. */
+    memoryMiB: number;
+    /** 1 to 10000; defaults to 100. */
+    concurrency?: number;
+    /** 0 to 16; defaults to 2. */
+    spares?: number;
+    /** 1 to 65535; defaults to 8080. */
+    port?: number;
+    /** Starts with /, no whitespace, at most 256 characters.
+     * Omit to check whether the port accepts connections. */
+    healthPath?: string;
+    /** Only Apps can keep copies awake. Omit this field, including zero. */
+    minCopies?: never;
+};
+export type CreateApp = Omit<CreateFunction, "minCopies"> & {
+    /** Defaults to 0. No greater than maxCopies. */
+    minCopies?: number;
+};
+export type UpdateApp = Partial<AppSettings> & {
+    name?: string | null;
+    labels?: Record<string, string>;
+};
+export type UpdateFunction = Omit<UpdateApp, "minCopies"> & {
+    minCopies?: never;
+};
+export type DeployState = "building" | "warming" | "switching" | "live" | "failed" | "superseded";
+export type AppDeploy = {
+    id: string;
+    version: number;
+    url: string;
+} & ({
+    state: "building" | "warming" | "switching" | "live";
+    error?: never;
+} | {
+    state: "failed" | "superseded";
+    error: {
+        code: "deploy_build_failed" | "deploy_health_failed" | "deploy_superseded";
+        message: string;
+        hint: string;
+        lastOutput: string;
+    };
+});
+export type DeployApp = ({
+    image: string;
+    build?: never;
+} | {
+    build: string;
+    image?: never;
+}) & {
+    env?: Record<string, string>;
+    port?: number;
+    healthPath?: string;
+    /** Return live, failed or superseded, including its URL/version or failure details. */
+    wait?: boolean;
+};
+export type AppVersion = {
+    version: number;
+    live: boolean;
+    previous: boolean;
+    saved: boolean;
+};
+export type AppCopy = {
+    id: string;
+    version: number;
+    region: string;
+    state: "starting" | "serving" | "draining" | "frozen" | "parked";
+    since: number;
+};
+export type DeployGetOptions = RequestOptions & {
+    waitFor?: DeployState;
+    timeoutSeconds?: number;
+};
+/** 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?: 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. */
+    waitDeploy: (id: string, deployId: string, options?: AppWaitOptions) => Promise<AppDeploy>;
+    rollback: (id: string, options?: AppDeleteOptions) => Promise<AppDeploy>;
+    versions: (id: string, options?: RequestOptions) => Promise<AppVersion[]>;
+    copies: (id: string, options?: RequestOptions) => Promise<AppCopy[]>;
+    update: (id: string, input: UpdateApp, options?: RequestOptions) => Promise<App>;
+    /** 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?: 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?: 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. */
+    waitDeploy: (id: string, deployId: string, options?: AppWaitOptions) => Promise<AppDeploy>;
+    rollback: (id: string, options?: AppDeleteOptions) => Promise<AppDeploy>;
+    versions: (id: string, options?: RequestOptions) => Promise<AppVersion[]>;
+    copies: (id: string, options?: RequestOptions) => Promise<AppCopy[]>;
+    update: (id: string, input: UpdateFunction, options?: RequestOptions) => Promise<RuntimeFunction>;
+    /** 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?: ResourceDeleteOptions) => Promise<RuntimeFunction>;
+};

package/dist/products/apps.js

@@ -0,0 +1,60 @@
+import { enc, following, resource, } from "./resources.js";
+function copies(t, plural) {
+    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({
+            method: "GET",
+            path: `${base}/${enc(id)}/deploys/${enc(deployId)}`,
+            query: { waitFor, timeoutSeconds },
+            ...request,
+        });
+    };
+    const followDeploy = async (id, record, request, pause) => {
+        while (!["live", "failed", "superseded"].includes(record.state)) {
+            record = await getDeploy(id, record.id, { ...request, waitFor: "live", timeoutSeconds: 60 });
+            if (!["live", "failed", "superseded"].includes(record.state))
+                await pause();
+        }
+        return record;
+    };
+    const writeDeploy = (id, verb, body, wait, options) => {
+        const { pollMs, ...request } = options;
+        const write = (rest) => t.json({ method: "POST", path: `${base}/${enc(id)}/${verb}`, body, ...rest });
+        if (!wait)
+            return write(request);
+        return following({ ...request, pollMs, idempotencyKey: request.idempotencyKey ?? crypto.randomUUID() }, async (rest, pause) => followDeploy(id, await write(rest), rest, pause));
+    };
+    return {
+        /** Create a resource waiting for its first version. Defaults belong to
+         * the API, so the SDK does not override them. */
+        create: shape.create,
+        get,
+        list: shape.list,
+        deploy: (id, input, options = {}) => {
+            const { wait = false, ...body } = input;
+            return writeDeploy(id, "deploys", body, wait, options);
+        },
+        getDeploy,
+        /** Resume by deploy id after a process restart, without creating another version. */
+        waitDeploy: (id, deployId, options = {}) => following(options, async (request, pause) => followDeploy(id, await getDeploy(id, deployId, request), request, pause)),
+        rollback: (id, options = {}) => {
+            const { wait = false, ...request } = options;
+            return writeDeploy(id, "rollback", {}, wait, request);
+        },
+        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: 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 = {}) => shape.wait(id, target, options),
+        delete: shape.delete,
+    };
+}
+export function apps(t) {
+    return copies(t, "apps");
+}
+export function functions(t) {
+    return copies(t, "functions");
+}