withruntime 0.4.0 → 0.5.1

package/dist/e2b/sandbox.d.ts

@@ -165,8 +165,13 @@ export declare class Sandbox {
     getPublicHost(port: number): Promise<string>;
     get pty(): never;
     get git(): never;
-    getMetrics(): Promise<never>;
-    static getMetrics(): Promise<never>;
+    /** E2B's metrics, from Runtime's measured readings (`sbx.metrics()`): CPU
+     * as a percent of the sandbox's vCPUs and resident memory, one entry per
+     * host reading (every minute by default) between `start` and `end`, kept
+     * 24 hours at that resolution. Disk use inside the sandbox is not measured:
+     * `diskUsed` is null and `diskTotal` is the disk's size. */
+    getMetrics(opts?: MetricsOpts): Promise<E2BSandboxMetrics[]>;
+    static getMetrics(sandboxId: string, opts?: MetricsOpts & SandboxApiOpts): Promise<E2BSandboxMetrics[]>;
     updateNetwork(): Promise<never>;
     uploadUrl(): Promise<never>;
     downloadUrl(): Promise<never>;
@@ -181,3 +186,18 @@ export declare class SandboxPaginator {
     get nextToken(): string | undefined;
     nextItems(): Promise<SandboxInfo[]>;
 }
+type MetricsOpts = {
+    start?: Date | number;
+    end?: Date | number;
+};
+export type E2BSandboxMetrics = {
+    timestamp: Date;
+    cpuUsedPct: number;
+    cpuCount: number;
+    memUsed: number;
+    memTotal: number;
+    /** Not measured by Runtime: null. */
+    diskUsed: number | null;
+    diskTotal: number;
+};
+export {};

package/dist/e2b/sandbox.js

@@ -35,8 +35,6 @@ function leaseSeconds(timeoutMs) {
 function onLeaseEnd(lifecycle) {
     if (!lifecycle)
         return "stop";
-    if (lifecycle.autoResume)
-        throw new NotSupportedError("Auto-resume on traffic (lifecycle.autoResume)", "Wake a paused sandbox with Sandbox.connect(id) before sending it work.");
     const action = typeof lifecycle.onTimeout === "string" ? lifecycle.onTimeout : lifecycle.onTimeout.action;
     if (typeof lifecycle.onTimeout === "object" && lifecycle.onTimeout.keepMemory === false)
         throw new NotSupportedError("A files-only pause (keepMemory: false)", "Runtime's pause keeps memory and files; leave keepMemory out.");
@@ -119,7 +117,10 @@ function infoOf(runtime) {
         cpuCount: info.vcpu,
         memoryMB: info.memoryMiB,
         envdVersion: "runtime",
-        lifecycle: { onTimeout: info.onLeaseEnd === "stop" ? "kill" : "pause", autoResume: false },
+        lifecycle: {
+            onTimeout: info.onLeaseEnd === "stop" ? "kill" : "pause",
+            autoResume: info.autoWake === true,
+        },
     };
 }
 function unsupported(feature, alternative) {
@@ -186,6 +187,9 @@ export class Sandbox {
         const input = {
             timeoutSeconds: leaseSeconds(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
             onLeaseEnd: onLeaseEnd(opts.lifecycle),
+            // With a lifecycle, E2B resumes a paused sandbox on traffic only when
+            // asked (autoResume); Runtime's automatic wake is the same thing (0093).
+            ...(opts.lifecycle ? { autoWake: opts.lifecycle.autoResume === true } : {}),
             ...(opts.metadata && Object.keys(opts.metadata).length ? { labels: opts.metadata } : {}),
             ...(opts.allowInternetAccess === false ? { network: { internet: false } } : {}),
         };
@@ -347,11 +351,18 @@ export class Sandbox {
     get git() {
         throw new NotSupportedError("E2B's git module (deprecated by E2B too)", "Run git with sandbox.commands.run('git ...'); git is installed.");
     }
-    getMetrics() {
-        return unsupported("Sandbox metrics (getMetrics)", "Runtime reports CPU, memory and charges per sandbox in `npx withruntime usage` and runtime.usage().");
+    /** E2B's metrics, from Runtime's measured readings (`sbx.metrics()`): CPU
+     * as a percent of the sandbox's vCPUs and resident memory, one entry per
+     * host reading (every minute by default) between `start` and `end`, kept
+     * 24 hours at that resolution. Disk use inside the sandbox is not measured:
+     * `diskUsed` is null and `diskTotal` is the disk's size. */
+    async getMetrics(opts = {}) {
+        return e2bMetrics(this.#runtime, opts);
     }
-    static getMetrics() {
-        return unsupported("Sandbox metrics (getMetrics)", "Runtime reports CPU, memory and charges per sandbox in `npx withruntime usage` and runtime.usage().");
+    static async getMetrics(sandboxId, opts = {}) {
+        const client = clientFor(opts);
+        const runtime = await guard("sandbox", () => client.sandboxes.get(sandboxId, request(opts)));
+        return e2bMetrics(runtime, opts);
     }
     updateNetwork() {
         return unsupported("E2B's network rules (updateNetwork)", "Use sandbox.runtime.network.set({ internet, allow, deny }).");
@@ -456,3 +467,24 @@ export class SandboxPaginator {
         return (page?.data ?? []).map(infoOf);
     }
 }
+async function e2bMetrics(runtime, opts) {
+    const start = opts.start === undefined ? Date.now() - 15 * 60_000 : new Date(opts.start).getTime();
+    const end = opts.end === undefined ? Date.now() : new Date(opts.end).getTime();
+    const span = Date.now() - start;
+    const range = span <= 15 * 60_000 ? "15m" : span <= 3_600_000 ? "1h" : span <= 6 * 3_600_000 ? "6h" : "24h";
+    const metrics = await runtime.metrics({ range });
+    return metrics.points
+        .filter((point) => {
+        const at = Date.parse(point.at);
+        return at >= start - metrics.stepSeconds * 1000 && at <= end && point.cpuPercent !== null;
+    })
+        .map((point) => ({
+        timestamp: new Date(point.at),
+        cpuUsedPct: point.cpuPercent,
+        cpuCount: metrics.vcpu,
+        memUsed: point.memoryBytes,
+        memTotal: metrics.memoryLimitBytes,
+        diskUsed: null,
+        diskTotal: metrics.diskLimitBytes,
+    }));
+}

package/dist/errors.d.ts

@@ -1,6 +1,8 @@
-/** Every failure the SDK raises. `code` is stable and machine-readable,
- * `hint` says what to do next, and `requestId` is what to quote in a report
- * (runtime.feedback.submit, `runtime feedback`, or support). */
+/** Refusals of a create that clear when a sandbox stops or pauses, or a host
+ * frees room: the trial's slots, an email domain's trial slots, the account's
+ * quota and the region's capacity. `sandboxes.create` waits them out, retrying
+ * with the same key and input, for up to `waitForCapacityMs`. */
+export declare const WAITS_FOR_ROOM: ReadonlySet<string>;
 export declare class RuntimeError extends Error {
     readonly code: string;
     readonly status: number;
@@ -21,7 +23,11 @@ export declare class RuntimeError extends Error {
         retryAfterMs?: number;
         cause?: unknown;
     });
-    /** Retrying this exact call (the SDK keeps the key) is safe and may work. */
+    /** Retrying this exact call (the SDK keeps the key) is safe and may work.
+     * True for no_capacity and trial_busy as well, which clear by themselves when
+     * a host frees room or a trial sandbox stops. `sandboxes.create` already
+     * waits for those (see `waitForCapacityMs`), so seeing one from a create
+     * means the wait ran out or was switched off. */
     get retryable(): boolean;
     toString(): string;
 }

package/dist/errors.js

@@ -1,6 +1,21 @@
 /** Every failure the SDK raises. `code` is stable and machine-readable,
  * `hint` says what to do next, and `requestId` is what to quote in a report
  * (runtime.feedback.submit, `runtime feedback`, or support). */
+/** Switched off on purpose: retrying cannot change them. */
+const DELIBERATE = new Set(["fork_unavailable", "previews_unavailable", "unavailable"]);
+/** Refusals that pass on their own: a host frees room, a trial slot frees. */
+const PASSING = new Set(["no_capacity", "trial_busy"]);
+/** Refusals of a create that clear when a sandbox stops or pauses, or a host
+ * frees room: the trial's slots, an email domain's trial slots, the account's
+ * quota and the region's capacity. `sandboxes.create` waits them out, retrying
+ * with the same key and input, for up to `waitForCapacityMs`. */
+export const WAITS_FOR_ROOM = new Set([
+    "trial_busy",
+    "trial_domain_limit",
+    "trial_capacity",
+    "quota_exceeded",
+    "no_capacity",
+]);
 export class RuntimeError extends Error {
     code;
     status;
@@ -26,13 +41,18 @@ export class RuntimeError extends Error {
         if (init.retryAfterMs !== undefined)
             this.retryAfterMs = init.retryAfterMs;
     }
-    /** Retrying this exact call (the SDK keeps the key) is safe and may work. */
+    /** Retrying this exact call (the SDK keeps the key) is safe and may work.
+     * True for no_capacity and trial_busy as well, which clear by themselves when
+     * a host frees room or a trial sandbox stops. `sandboxes.create` already
+     * waits for those (see `waitForCapacityMs`), so seeing one from a create
+     * means the wait ran out or was switched off. */
     get retryable() {
-        return (this.status === 0 ||
-            this.status === 429 ||
-            this.status === 502 ||
-            this.status === 503 ||
-            this.status === 504);
+        if (DELIBERATE.has(this.code))
+            return false;
+        // A fork asking for more copies than the trial runs at once never fits.
+        if (PASSING.has(this.code))
+            return this.details?.field !== "count";
+        return [0, 429, 502, 503, 504].includes(this.status);
     }
     toString() {
         return `${this.name} [${this.code}${this.status ? ` ${this.status}` : ""}]: ${this.message}${this.hint ? `\nHint: ${this.hint}` : ""}${this.requestId ? `\nRequest: ${this.requestId}` : ""}`;

package/dist/image-context.d.ts

@@ -0,0 +1,39 @@
+export declare const CONTEXT_LIMITS: {
+    /** The archive, compressed: what is uploaded. */
+    bytes: number;
+    files: number;
+    chunkBytes: number;
+};
+export type ContextFile = {
+    path: string;
+    sha256: string;
+    size: number;
+    mode: number;
+};
+export type PackedContext = {
+    archive: Uint8Array;
+    files: ContextFile[];
+    /** The .dockerignore that was applied, sent so the server applies it too. */
+    dockerignore?: string;
+};
+/** A .dockerignore as Docker reads it: `#` comments, `!` re-includes, `**`
+ * crosses directories, a pattern naming a directory excludes what is in it,
+ * and the last matching pattern decides. The same rules as the server's
+ * (packages/cloud/src/images/dockerfile.ts `dockerignoreFilter`). */
+export declare function dockerignoreFilter(text: string | undefined): (path: string) => boolean;
+/** The context of a folder: its .dockerignore (or `<Dockerfile>.dockerignore`)
+ * applied, `.git` left out when there is none. Symbolic links are left out:
+ * COPY reads files. */
+export declare function packContext(folder: string, options?: {
+    dockerignore?: string;
+    dockerfile?: string;
+}): Promise<PackedContext>;
+/** The archive cut into the 1 MiB chunks the server stores by digest. */
+export declare function chunkArchive(archive: Uint8Array): Promise<{
+    sha256: string;
+    size: number;
+    chunks: {
+        sha256: string;
+        bytes: Uint8Array;
+    }[];
+}>;

package/dist/image-context.js

@@ -0,0 +1,176 @@
+import { lstat, readdir, readFile } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+import { gzipSync } from "node:zlib";
+import { tarHeader } from "./tar.js";
+/* A Dockerfile's build context, made from a folder the way `docker build`
+ * makes it: every file the .dockerignore does not exclude, in one gzipped tar
+ * archive, with a list of the files and their SHA-256 for the server to
+ * resolve COPY against. The archive is deterministic (sorted, no times, no
+ * owners), so an unchanged folder gives the same chunks and a rebuild
+ * uploads nothing. Node and Bun only: it reads the file system. */
+export const CONTEXT_LIMITS = {
+    /** The archive, compressed: what is uploaded. */
+    bytes: 100 * 1_048_576,
+    files: 20_000,
+    chunkBytes: 1_048_576,
+};
+/** A .dockerignore as Docker reads it: `#` comments, `!` re-includes, `**`
+ * crosses directories, a pattern naming a directory excludes what is in it,
+ * and the last matching pattern decides. The same rules as the server's
+ * (packages/cloud/src/images/dockerfile.ts `dockerignoreFilter`). */
+export function dockerignoreFilter(text) {
+    if (text === undefined || text.trim() === "")
+        return () => false;
+    const rules = [];
+    for (const raw of text.replace(/\r\n?/g, "\n").split("\n")) {
+        let line = raw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const negate = line.startsWith("!");
+        if (negate)
+            line = line.slice(1).trim();
+        line = normalize(line.replace(/^\/+/, "")).replace(/\/+$/, "");
+        if (!line || line === ".")
+            continue;
+        let source = "";
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            if (char === "*" && line[i + 1] === "*") {
+                if (line[i + 2] === "/") {
+                    source += "(?:.*/)?";
+                    i += 2;
+                }
+                else {
+                    source += ".*";
+                    i += 1;
+                }
+            }
+            else if (char === "*")
+                source += "[^/]*";
+            else if (char === "?")
+                source += "[^/]";
+            else if (char === "[") {
+                const end = line.indexOf("]", i + 1);
+                if (end < 0)
+                    source += "\\[";
+                else {
+                    source += `[${line
+                        .slice(i + 1, end)
+                        .replace(/^!/, "^")
+                        .replace(/\\/g, "\\\\")}]`;
+                    i = end;
+                }
+            }
+            else if (char === "\\" && i + 1 < line.length) {
+                source += line[++i].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            }
+            else
+                source += char.replace(/[.+^${}()|\\]/g, "\\$&");
+        }
+        try {
+            rules.push({ negate, regex: new RegExp(`^${source}$`) });
+        }
+        catch {
+            throw new Error(`.dockerignore: invalid pattern ${JSON.stringify(raw.trim())}`);
+        }
+    }
+    return (path) => {
+        const parts = path.split("/");
+        let excluded = false;
+        for (const rule of rules) {
+            let hit = false;
+            for (let n = parts.length; n >= 1 && !hit; n--)
+                hit = rule.regex.test(parts.slice(0, n).join("/"));
+            if (hit)
+                excluded = !rule.negate;
+        }
+        return excluded;
+    };
+}
+/** posix.normalize, without importing a path module into this function. */
+function normalize(path) {
+    const out = [];
+    for (const part of path.split("/")) {
+        if (part === "" || part === ".")
+            continue;
+        if (part === "..")
+            out.pop();
+        else
+            out.push(part);
+    }
+    return out.join("/") || ".";
+}
+async function sha256(bytes) {
+    const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+    return Buffer.from(digest).toString("hex");
+}
+/** The context of a folder: its .dockerignore (or `<Dockerfile>.dockerignore`)
+ * applied, `.git` left out when there is none. Symbolic links are left out:
+ * COPY reads files. */
+export async function packContext(folder, options = {}) {
+    const root = resolve(folder);
+    let dockerignore = options.dockerignore;
+    if (dockerignore === undefined)
+        for (const candidate of [
+            ...(options.dockerfile ? [`${resolve(root, options.dockerfile)}.dockerignore`] : []),
+            join(root, ".dockerignore"),
+        ]) {
+            dockerignore = await readFile(candidate, "utf8").catch(() => undefined);
+            if (dockerignore !== undefined)
+                break;
+        }
+    const ignored = dockerignoreFilter(dockerignore ?? ".git\n");
+    const reincludes = /^\s*!/m.test(dockerignore ?? "");
+    const files = [];
+    const parts = [];
+    let total = 0;
+    async function walk(directory) {
+        for (const name of (await readdir(directory)).sort()) {
+            const full = join(directory, name);
+            const path = relative(root, full).split(sep).join("/");
+            const info = await lstat(full);
+            if (info.isDirectory()) {
+                // A directory excluded outright is not walked, unless a later `!`
+                // rule could bring something in it back.
+                if (ignored(path) && !reincludes)
+                    continue;
+                await walk(full);
+            }
+            else if (info.isFile()) {
+                if (ignored(path))
+                    continue;
+                if (files.length >= CONTEXT_LIMITS.files)
+                    throw new Error(`The build context has more than ${CONTEXT_LIMITS.files} files. Leave some out with a .dockerignore.`);
+                const data = new Uint8Array(await readFile(full));
+                total += data.length;
+                const mode = info.mode & 0o777;
+                files.push({ path, sha256: await sha256(data), size: data.length, mode });
+                parts.push(tarHeader(path, data.length, mode, "0", "", 0), data);
+                const pad = (512 - (data.length % 512)) % 512;
+                if (pad)
+                    parts.push(new Uint8Array(pad));
+            }
+        }
+    }
+    await walk(root);
+    parts.push(new Uint8Array(1024));
+    const tar = new Uint8Array(parts.reduce((n, p) => n + p.length, 0) || 1024);
+    let offset = 0;
+    for (const part of parts) {
+        tar.set(part, offset);
+        offset += part.length;
+    }
+    const archive = new Uint8Array(gzipSync(tar, { level: 6 }));
+    if (archive.length > CONTEXT_LIMITS.bytes)
+        throw new Error(`The build context is ${Math.ceil(archive.length / 1_048_576)} MiB compressed (${Math.ceil(total / 1_048_576)} MiB of files); the most is ${CONTEXT_LIMITS.bytes / 1_048_576} MiB. Leave build outputs and dependencies out with a .dockerignore.`);
+    return { archive, files, ...(dockerignore === undefined ? {} : { dockerignore }) };
+}
+/** The archive cut into the 1 MiB chunks the server stores by digest. */
+export async function chunkArchive(archive) {
+    const chunks = [];
+    for (let at = 0; at < archive.length; at += CONTEXT_LIMITS.chunkBytes) {
+        const bytes = archive.subarray(at, Math.min(archive.length, at + CONTEXT_LIMITS.chunkBytes));
+        chunks.push({ sha256: await sha256(bytes), bytes });
+    }
+    return { sha256: await sha256(archive), size: archive.length, chunks };
+}

package/dist/index.d.ts

@@ -7,12 +7,16 @@
 import type { Runtime } from "./client.js";
 import { type RuntimeOptions } from "./client.js";
 import { Sandbox as SandboxClass } from "./sandbox.js";
-import type { CreateSandbox } from "./types.js";
+import type { CreateSandbox, KeepAliveOptions } from "./types.js";
 import type { RequestOptions } from "./transport.js";
 export { Runtime, Sandboxes, FeedbackApi, SupportApi, type RuntimeOptions, type SupportReply, } from "./client.js";
 export { Files, Process, Processes, Terminal } from "./sandbox.js";
+export { Tunnel, TunnelStream, type PortForward } from "./tunnel.js";
 export { Page } from "./page.js";
 export type { KeyLimits } from "./products/limits.js";
+export type { AuditEvent, AuditPage } from "./products/audit.js";
+export type { Secret, SetSecret } from "./products/secrets.js";
+export { verifyWebhook, WebhookVerificationError, type MetricPoint, type MetricRange, type OtelExport, type RuntimeEvent, type SandboxMetrics, type Webhook, type WebhookDelivery, type WebhookEventType, } from "./products/observability.js";
 export { Snapshots, type Snapshot, type SnapshotOptions } from "./snapshots.js";
 export { Transport, VERSION, apiOrigin, type RequestOptions, type Call } from "./transport.js";
 export * from "./errors.js";
@@ -20,9 +24,22 @@ export type * from "./types.js";
 /** A sandbox. `Sandbox.create()` uses RUNTIME_API_KEY; `runtime.sandboxes`
  * does the same with an explicit client. */
 export declare class Sandbox extends SandboxClass {
-    /** Creates a sandbox (every field optional) and waits until it is running. */
+    /** Creates a sandbox (every field optional) and waits until it is running.
+     * `keepAlive: true` (or its options) extends its lease in the background
+     * until you stop it; see `sandbox.keepAlive()`. */
     static create(input?: CreateSandbox & {
         wait?: boolean;
+        keepAlive?: boolean | KeepAliveOptions;
+    }, options?: RequestOptions & {
+        client?: Runtime;
+    }): Promise<SandboxClass>;
+    /** The sandbox named `name` in this account, ready to use: running as it
+     * is, woken if it is paused, restarted if it is stopped and persistent, or
+     * created with `input` when no sandbox has the name. `sandbox.info.reused`
+     * says which. The other fields apply only when it is created. */
+    static getOrCreate(name: string, input?: Omit<CreateSandbox, "name" | "getOrCreate"> & {
+        wait?: boolean;
+        keepAlive?: boolean | KeepAliveOptions;
     }, options?: RequestOptions & {
         client?: Runtime;
     }): Promise<SandboxClass>;

package/dist/index.js

@@ -2,17 +2,32 @@ import { defaultClient } from "./client.js";
 import { Sandbox as SandboxClass } from "./sandbox.js";
 export { Runtime, Sandboxes, FeedbackApi, SupportApi, } from "./client.js";
 export { Files, Process, Processes, Terminal } from "./sandbox.js";
+export { Tunnel, TunnelStream } from "./tunnel.js";
 export { Page } from "./page.js";
+export { verifyWebhook, WebhookVerificationError, } from "./products/observability.js";
 export { Snapshots } from "./snapshots.js";
 export { Transport, VERSION, apiOrigin } from "./transport.js";
 export * from "./errors.js";
 /** A sandbox. `Sandbox.create()` uses RUNTIME_API_KEY; `runtime.sandboxes`
  * does the same with an explicit client. */
 export class Sandbox extends SandboxClass {
-    /** Creates a sandbox (every field optional) and waits until it is running. */
+    /** Creates a sandbox (every field optional) and waits until it is running.
+     * `keepAlive: true` (or its options) extends its lease in the background
+     * until you stop it; see `sandbox.keepAlive()`. */
     static async create(input = {}, options = {}) {
         const { client, ...rest } = options;
-        return (client ?? defaultClient()).sandboxes.create(input, rest);
+        const { keepAlive, ...body } = input;
+        const sandbox = await (client ?? defaultClient()).sandboxes.create(body, rest);
+        if (keepAlive)
+            sandbox.keepAlive(keepAlive === true ? {} : keepAlive);
+        return sandbox;
+    }
+    /** The sandbox named `name` in this account, ready to use: running as it
+     * is, woken if it is paused, restarted if it is stopped and persistent, or
+     * created with `input` when no sandbox has the name. `sandbox.info.reused`
+     * says which. The other fields apply only when it is created. */
+    static async getOrCreate(name, input = {}, options = {}) {
+        return Sandbox.create({ ...input, name, getOrCreate: true }, options);
     }
     /** Reconnects to an existing sandbox by id. */
     static async connect(id, options = {}) {

package/dist/keys.d.ts

@@ -0,0 +1,43 @@
+export type KeyAccess = "full" | "read";
+export type KeyRequest = {
+    /** The key's name, and its agent's. */
+    name: string;
+    access: KeyAccess;
+    /** The most its agent may spend in any 24 hours, or null for none. */
+    dailyLimitMicros: number | null;
+};
+export type CreatedKey = KeyRequest & {
+    key: string;
+    keyId: string;
+    agentId: string;
+    orgId: string;
+    /** Always until revoked, as on the keys page. */
+    expires: null;
+};
+export type KeyRequestOptions = {
+    fetch?: typeof fetch;
+    sleep?: (ms: number) => Promise<void>;
+    /** Where the link, the code and progress go: standard error, never stdout. */
+    notify?: (message: string) => void;
+    openBrowser?: (url: string) => Promise<void>;
+    /** Whether a person is at this terminal, so a browser is worth opening. */
+    interactive?: boolean;
+    /** What this computer calls itself, shown to the owner beside the code. */
+    machine?: string;
+    /** Runs `cancel` if the command is interrupted before the key arrives;
+     * returns a function that stops listening. */
+    onInterrupt?: (cancel: () => Promise<void>) => () => void;
+};
+/** Whole microdollars from a daily limit typed in dollars ("25", "7.5",
+ * "$1,000.10"), read as digits rather than through a float, from $0.01 to
+ * $1,000,000: the keys page's own rule (apps/cloud-web/src/app/account/keys/limit.ts). */
+export declare function dailyLimitMicros(typed: string): number;
+/**
+ * Asks for a key, waits for an owner to approve it in the browser, and hands
+ * it back with `confirm`, which tells the website it arrived. Call `confirm`
+ * after the key is shown: it clears the sealed copy the website held for
+ * delivery and turns the owner's page to "Key created".
+ */
+export declare function createKey(request: KeyRequest, env: NodeJS.ProcessEnv, options?: KeyRequestOptions): Promise<CreatedKey & {
+    confirm: () => Promise<void>;
+}>;