withruntime 0.11.2 → 0.12.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/apps.d.ts

@@ -0,0 +1,176 @@
+import { Page } from "../page.js";
+import type { RequestOptions, Transport } from "../transport.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;
+};
+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;
+};
+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>>;
+    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?: AppDeleteOptions) => 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>>;
+    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?: AppDeleteOptions) => Promise<RuntimeFunction>;
+};

package/dist/products/apps.js

@@ -0,0 +1,165 @@
+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);
+    }
+}
+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 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: (input, options) => t.json({ method: "POST", path: base, body: input, ...options }),
+        get,
+        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: (id, input, options) => t.json({ method: "POST", path: `${base}/${enc(id)}:update`, body: input, ...options }),
+        /** 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)));
+        },
+    };
+}
+export function apps(t) {
+    return copies(t, "apps");
+}
+export function functions(t) {
+    return copies(t, "functions");
+}