withruntime 0.14.0 → 0.16.1

package/dist/machine.d.ts

@@ -57,18 +57,21 @@ export declare abstract class Machine<Info extends MachineInfo, Settings extends
      * answers the same. */
     delete(options?: RequestOptions): Promise<Deleted>;
     /** Carries on a paused sandbox; for one with a time limit,
-     * `timeoutSeconds` is its new one. */
-    wake(options?: RequestOptions & {
-        wait?: boolean;
+     * `timeoutSeconds` is its new one. A wake stays on its server; when that
+     * server is full for now (`no_capacity`) it waits for room as `create`
+     * does, up to `waitForCapacityMs` (the client's, two minutes by default). */
+    wake(options?: LifecycleOptions & {
         timeoutSeconds?: number;
     }): Promise<this>;
-    /** More time before its time limit ends (at most an hour ahead of now). A
+    /** More time before its time limit ends (at most 24 hours ahead of now). A
      * sandbox with no time limit needs none: the call answers at once and
-     * changes nothing. */
+     * changes nothing. To set the end sooner, or give one with no limit a limit,
+     * `update({ timeoutSeconds })`. */
     extend(seconds: number, options?: RequestOptions): Promise<this>;
-    /** Changes its name, labels, automatic wake, idle pause or persistence;
-     * fields left out stay as they are. `persistent: true` keeps it running
-     * while credit lasts (paid only). */
+    /** Changes its name, labels, automatic wake, idle pause, time limit, end
+     * action or persistence; fields left out stay as they are. `persistent:
+     * true` keeps it running while credit lasts (paid only). `timeoutSeconds`
+     * ends it that long from now, sooner or later than before (0: no limit). */
     update(settings: Settings, options?: RequestOptions): Promise<this>;
     /** Moves it to another image (id, name, name:tag or name@version), keeping
      * its id, /workspace (its home: dotfiles, pip --user and npm -g installs),
@@ -92,9 +95,12 @@ export declare abstract class Machine<Info extends MachineInfo, Settings extends
      * while a snapshot or fork of it is being taken. `restart` is optional:
      * true is the only value, and it is sent either way, so an API from before
      * it was optional accepts the call too. */
-    resize(size: {
+    resize(
+    /** diskMiB only grows; the filesystem fills it at the restart. */
+    size: {
         vcpu?: number;
         memoryMiB?: number;
+        diskMiB?: number;
     }, options?: RequestOptions & {
         restart?: true;
     }): Promise<this>;
@@ -116,10 +122,10 @@ export declare abstract class Machine<Info extends MachineInfo, Settings extends
      * `timeoutMs` (ten minutes unless given) mid-capture, it stays paused and
      * the error names the snapshot. */
     snapshot(options?: SnapshotOptions & RequestOptions): Promise<Snapshot>;
-    /** Starts a stopped persistent sandbox again from its disk (memory is not kept). */
-    restart(options?: RequestOptions & {
-        wait?: boolean;
-    }): Promise<this>;
+    /** Starts a stopped persistent sandbox again from its disk (memory is not
+     * kept), waiting for room on a full server as `wake` does. Its image's
+     * start command runs again, reported in `info.start`. */
+    restart(options?: LifecycleOptions): Promise<this>;
     /** The end of an `await using` block. A sandbox this client created is
      * deleted, as E2B's block kills it, unless it was created with
      * `keep: true`; one it found with `get` or `getOrCreate` is stopped, which
@@ -137,6 +143,15 @@ export type CreateOptions = RequestOptions & {
      * next try: to tell a person why nothing has happened yet. */
     onCapacityWait?: (refusal: RuntimeError, waitMs: number) => void;
 };
+/** How `wake` and `restart` wait when the sandbox's server is full for now. */
+export type LifecycleOptions = RequestOptions & {
+    wait?: boolean;
+    /** How long to keep retrying `no_capacity` and the like. Default: the
+     * client's, two minutes; 0 fails at once. */
+    waitForCapacityMs?: number;
+    /** Called before each wait, with the refusal and the milliseconds until the next try. */
+    onCapacityWait?: (refusal: RuntimeError, waitMs: number) => void;
+};
 /** A machine product's collection: `runtime.<product>`. */
 export declare abstract class Machines<M extends Machine<Info, object, Deleted>, Info extends MachineInfo, Create extends {
     name?: string;

package/dist/machine.js

@@ -41,7 +41,7 @@ export function machinePage(product, t, wrap, body, query, options = {}) {
 }
 /** One machine: its record and the verbs every machine product shares. */
 /** Machines `create` made, which the end of an `await using` block deletes
- * (Marc, 6 October 2026: deleted unless the code passes `keep: true`). One
+ * (6 October 2026: deleted unless the code passes `keep: true`). One
  * from `get`, or an existing one `getOrCreate` found, is only stopped. */
 const deleteAtBlockEnd = new WeakSet();
 export class Machine {
@@ -111,7 +111,9 @@ export class Machine {
         return deleteMachine(this.#product, this.#t, this.id, options);
     }
     /** Carries on a paused sandbox; for one with a time limit,
-     * `timeoutSeconds` is its new one. */
+     * `timeoutSeconds` is its new one. A wake stays on its server; when that
+     * server is full for now (`no_capacity`) it waits for room as `create`
+     * does, up to `waitForCapacityMs` (the client's, two minutes by default). */
     async wake(options = {}) {
         const { timeoutSeconds, ...rest } = options;
         try {
@@ -128,15 +130,17 @@ export class Machine {
             return this;
         }
     }
-    /** More time before its time limit ends (at most an hour ahead of now). A
+    /** More time before its time limit ends (at most 24 hours ahead of now). A
      * sandbox with no time limit needs none: the call answers at once and
-     * changes nothing. */
+     * changes nothing. To set the end sooner, or give one with no limit a limit,
+     * `update({ timeoutSeconds })`. */
     async extend(seconds, options = {}) {
         return this.#lifecycle("extend", { ...options, wait: false }, { seconds });
     }
-    /** Changes its name, labels, automatic wake, idle pause or persistence;
-     * fields left out stay as they are. `persistent: true` keeps it running
-     * while credit lasts (paid only). */
+    /** Changes its name, labels, automatic wake, idle pause, time limit, end
+     * action or persistence; fields left out stay as they are. `persistent:
+     * true` keeps it running while credit lasts (paid only). `timeoutSeconds`
+     * ends it that long from now, sooner or later than before (0: no limit). */
     async update(settings, options = {}) {
         return this.#lifecycle("update", { ...options, wait: false }, { ...settings });
     }
@@ -171,7 +175,9 @@ export class Machine {
      * while a snapshot or fork of it is being taken. `restart` is optional:
      * true is the only value, and it is sent either way, so an API from before
      * it was optional accepts the call too. */
-    async resize(size, options = {}) {
+    async resize(
+    /** diskMiB only grows; the filesystem fills it at the restart. */
+    size, options = {}) {
         const { restart = true, ...rest } = options;
         this.#keep(await this.#t.json({
             method: "POST",
@@ -277,20 +283,26 @@ export class Machine {
         await this.refresh(request());
         // Straight after a fork or a wake the sandbox is still `resuming`, and
         // after a pause still `pausing`: wait for where it is going, or a
-        // snapshot of it is refused as not paused (user lane, 23 September 2026).
+        // snapshot of it is refused as not paused (23 September 2026).
         if (this.state === "resuming" || this.state === "starting")
             await this.waitFor("running", request());
         else if (this.state === "pausing")
             await this.waitFor("paused", request());
         running = this.state === "running";
         // Check before entering cleanup: an abort during refresh must not pause or wake.
-        const pauseOptions = running ? request() : undefined;
+        request();
         let captured;
         let primary;
         let failed = false;
+        /** Whether the server may have left a running source paused: it answered
+         * before the capture was over, or not at all. */
+        let leftPaused = running;
         try {
-            if (running)
-                await this.pause(pauseOptions);
+            // One call: the server pauses a running source for the capture, and
+            // wakes it before it answers a capture that is over (ready or failed).
+            // Pausing, snapshotting and waking it from here took four calls: a
+            // repeat snapshot of a 4 GiB sandbox took 1.96 s at the median against
+            // 1.19 s for this one (15 October 2026).
             let snapshot = await this.#t.json({
                 method: "POST",
                 path: this.#path(":snapshot"),
@@ -300,6 +312,7 @@ export class Machine {
                 ...request(),
             });
             captured = snapshot;
+            leftPaused = running && snapshot.state === "capturing";
             // Prefer: wait is bounded on the server. A capture still in progress
             // must keep its source paused, or the worker refuses it after we wake.
             while (snapshot.state === "capturing") {
@@ -337,9 +350,17 @@ export class Machine {
         }
         // A capture still running needs its source paused: the worker fails one
         // whose source woke. The timeout says so and leaves the wake to the caller.
-        if (running && !late) {
+        if (leftPaused && !late) {
             try {
-                await this.wake();
+                // A call that failed may have been refused before anything paused
+                // (pausable: false, volumes): only a source that is paused is woken.
+                if (failed && captured === undefined)
+                    await this.refresh();
+                if (!failed ||
+                    captured !== undefined ||
+                    this.state === "paused" ||
+                    this.state === "pausing")
+                    await this.wake();
             }
             catch (wakeError) {
                 const recovery = {
@@ -365,17 +386,30 @@ export class Machine {
             throw primary;
         return captured;
     }
-    /** Starts a stopped persistent sandbox again from its disk (memory is not kept). */
+    /** Starts a stopped persistent sandbox again from its disk (memory is not
+     * kept), waiting for room on a full server as `wake` does. Its image's
+     * start command runs again, reported in `info.start`. */
     async restart(options = {}) {
         return this.#lifecycle("restart", options);
     }
     async #lifecycle(verb, options, body = {}) {
+        // A wake or restart refused for room ran nothing and is sent again with
+        // the same key (api.md, "A refusal is not kept"). Until 17 October 2026
+        // only create waited: the product check's wake was refused no_capacity
+        // in 36 ms on 16 October, where a create would have waited for room.
+        const room = verb === "wake" || verb === "restart"
+            ? {
+                waitForCapacityMs: options.waitForCapacityMs ?? this.#t.waitForCapacityMs,
+                ...(options.onCapacityWait ? { onCapacityWait: options.onCapacityWait } : {}),
+            }
+            : {};
         this.#keep(await this.#t.json({
             method: "POST",
             path: this.#path(`:${verb}`),
             body,
             wait: options.wait === false ? 0 : 60,
             ...requestOnly(options),
+            ...room,
         }));
         return this;
     }

package/dist/mcp.js

@@ -212,11 +212,16 @@ export async function serveMcp(env = process.env, options = {}) {
             await new Promise((resolve) => setTimeout(resolve, 10_000));
         }
     }
-    /** Starts forwarding with this key and tells the client its tools changed. */
+    /** Starts forwarding with this key and tells the client its tools changed.
+     * The client read CONNECT_INSTRUCTIONS on its own initialize and will not
+     * read instructions again, so the hosted server's (limits, safe writes,
+     * cleanup, the task) come back in this answer, or an agent's first session
+     * never sees them. Not every client re-lists tools when told; a restart of
+     * this server finds the saved key and serves them at once. */
     async function connected(found, agentName) {
         key = found;
         pending = undefined;
-        await post(JSON.stringify({
+        const { messages } = await post(JSON.stringify({
             jsonrpc: "2.0",
             id: "runtime-connect",
             method: "initialize",
@@ -224,7 +229,15 @@ export async function serveMcp(env = process.env, options = {}) {
         }));
         await post(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }));
         write({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
-        return `Connected${agentName ? ` as ${agentName}` : ""}. Runtime's tools are available now: list the tools again, then start with runtime_sandboxes_create.`;
+        const instructions = messages
+            .map((reply) => reply.result?.instructions)
+            .find((words) => typeof words === "string" && words.length > 0);
+        return [
+            `Connected${agentName ? ` as ${agentName}` : ""}. Runtime's tools are available now: list the tools again, then start with runtime_sandboxes_create. If they do not appear, restart this MCP server (or the client): the connection is saved, so it connects at once.`,
+            ...(instructions
+                ? ["", "Runtime's instructions, to follow from here:", "", instructions]
+                : []),
+        ].join("\n");
     }
     /** Not connected yet: answer the client here, with the tools that connect. */
     async function connectMode(message, id) {

package/dist/modal/index.d.ts

@@ -47,6 +47,7 @@ export declare class App {
     readonly name?: string | undefined;
     readonly environmentName?: string | undefined;
     constructor(appId: string, name?: string | undefined, environmentName?: string | undefined);
+    readonly info: RefusedAsync;
 }
 export declare class AppService {
     private readonly client;
@@ -90,6 +91,7 @@ export declare class VolumeService {
     fromName(name: string, params?: {
         createIfMissing?: boolean;
         environment?: string;
+        version?: 1 | 2;
     }): Promise<Volume>;
     delete(name: string, params?: {
         allowMissing?: boolean;
@@ -211,6 +213,14 @@ export declare class SandboxSnapshotService {
     constructor(client: ModalClient);
     fromId(snapshotId: string): Promise<SandboxSnapshot>;
 }
+/** `client.environments` (modal 0.11.1): refused, as `environment` options are. */
+export declare class EnvironmentService {
+    readonly fromName: RefusedAsync;
+    readonly objects: Refused;
+}
+export declare const Environment: Refused;
+export declare const EnvironmentAppsService: Refused;
+export declare const EnvironmentObjectsService: Refused;
 export type ModalClientParams = ClientOptions & {
     tokenId?: string;
     tokenSecret?: string;
@@ -237,6 +247,7 @@ export declare class ModalClient {
     readonly cloudBucketMounts: CloudBucketMountService;
     readonly sandboxSnapshots: SandboxSnapshotService;
     readonly proxies: ProxyService;
+    readonly environments: EnvironmentService;
     constructor(options?: ModalClientParams);
     /** Throws once close() was called, as Modal's client does. */
     open(): void;
@@ -292,11 +303,15 @@ export declare class SandboxService {
     create(app: App, image: Image, params?: SandboxCreateParams): Promise<Sandbox>;
     experimentalCreate(app: App, image: Image, params?: SandboxCreateParams): Promise<Sandbox>;
     fromId(id: string): Promise<Sandbox>;
+    /** The running sandbox of that name; with includeTerminated, when none
+     * runs, the one that stopped last (modal 0.11.1). */
     fromName(appName: string, name: string, params?: {
         environment?: string;
+        includeTerminated?: boolean;
     }): Promise<Sandbox>;
     experimentalFromName(appName: string, name: string, params?: {
         environment?: string;
+        includeTerminated?: boolean;
     }): Promise<Sandbox>;
     /** A new sandbox continuing a memory snapshot: its files, memory and
      * running entrypoint, under the snapshot's app and tags. */

package/dist/modal/index.js

@@ -1,5 +1,5 @@
 import { ConflictError as NativeConflictError, InvalidRequestError, NotFoundError as NativeNotFoundError, RateLimitError, RuntimeError, ServiceUnavailableError, } from "../errors.js";
-import { all, client, CompatibilityError, create, destroy, execOptions, only, refuse, region, } from "../compat/core.js";
+import { all, client, CompatibilityError, create, destroy, execOptions, only, refuse, refusal, refused, region, } from "../compat/core.js";
 import { GuestFiles } from "../compat/files.js";
 export { CompatibilityError };
 // Errors ----------------------------------------------------------------------
@@ -104,6 +104,9 @@ export class App {
         this.environmentName = environmentName;
     }
 }
+refuse("Modal", "App", App, {
+    info: "a Runtime app is a label on its sandboxes, with no lifecycle, Functions or Servers: list them with client.sandboxes.list({ appId: app.appId })",
+});
 export class AppService {
     client;
     constructor(client) {
@@ -183,9 +186,11 @@ export class VolumeService {
     }
     async fromName(name, params = {}) {
         this.client.open();
-        only("Modal volume", params, ["createIfMissing", "environment"]);
+        only("Modal volume", params, ["createIfMissing", "environment", "version"]);
         if (params.environment)
             throw new CompatibilityError("Modal", "named Modal environments");
+        if (params.version !== undefined)
+            throw new CompatibilityError("Modal", "VolumeFS versions; a Runtime volume has one format, so omit version");
         const found = await this.find(name);
         if (found)
             return new Volume(found.id, name);
@@ -402,6 +407,21 @@ export class SandboxSnapshotService {
         return new SandboxSnapshot(snapshot.id);
     }
 }
+// Environments ------------------------------------------------------------------
+const NO_ENVIRONMENTS = "Runtime has no Modal environments: an account's sandboxes share one namespace, grouped by app name (client.apps.fromName) and tags";
+/** `client.environments` (modal 0.11.1): refused, as `environment` options are. */
+export class EnvironmentService {
+}
+refuse("Modal", "EnvironmentService", EnvironmentService, { fromName: NO_ENVIRONMENTS });
+Object.defineProperty(EnvironmentService.prototype, "objects", {
+    configurable: true,
+    get() {
+        throw refusal("Modal", "EnvironmentService.objects", NO_ENVIRONMENTS);
+    },
+});
+export const Environment = refused("Modal", "Environment", NO_ENVIRONMENTS);
+export const EnvironmentAppsService = refused("Modal", "EnvironmentAppsService", NO_ENVIRONMENTS);
+export const EnvironmentObjectsService = refused("Modal", "EnvironmentObjectsService", NO_ENVIRONMENTS);
 export class ModalClient {
     runtime;
     apps;
@@ -412,6 +432,7 @@ export class ModalClient {
     cloudBucketMounts = new CloudBucketMountService();
     sandboxSnapshots;
     proxies = new ProxyService();
+    environments = new EnvironmentService();
     #closed = false;
     constructor(options = {}) {
         if (options.endpoint !== undefined ||
@@ -458,7 +479,7 @@ export class ModalClient {
     }
     /** The Modal SDK version whose interface this adapter implements. */
     version() {
-        return "0.11.0";
+        return "0.11.1";
     }
     close() {
         // The transport owns no background connection; later calls fail as Modal's do.
@@ -619,14 +640,21 @@ export class SandboxService {
             throw new NotFoundError("Sandbox is not a Modal-compatible sandbox");
         return new Sandbox(s, new ContainerProcess(await modal(() => s.processes.get(p)), "text"), this.client);
     }
+    /** The running sandbox of that name; with includeTerminated, when none
+     * runs, the one that stopped last (modal 0.11.1). */
     async fromName(appName, name, params = {}) {
         this.client?.open();
-        only("Modal sandbox name", params, ["environment"]);
+        only("Modal sandbox name", params, ["environment", "includeTerminated"]);
         if (params.environment)
             throw new CompatibilityError("Modal", ENVIRONMENTS);
-        const s = (await all(this.runtime, "modal")).find((s) => s.info.labels["modal.app"] === appName &&
-            s.info.labels["modal.name"] === name &&
-            s.state === "running");
+        const named = (await all(this.runtime, "modal")).filter((s) => s.info.labels["modal.app"] === appName && s.info.labels["modal.name"] === name);
+        const ended = (s) => s.info.endedAt ?? s.info.createdAt ?? "";
+        const s = named.find((s) => s.state === "running") ??
+            (params.includeTerminated
+                ? named
+                    .filter((s) => s.state === "stopped")
+                    .sort((a, b) => ended(b).localeCompare(ended(a)))[0]
+                : undefined);
         if (!s)
             throw new NotFoundError(`Sandbox ${name} not found`);
         return this.fromId(s.id);

package/dist/morph/index.d.ts

@@ -0,0 +1,255 @@
+import type { Runtime } from "../client.js";
+import type { Preview } from "../products/previews.js";
+import { Sandbox } from "../sandbox.js";
+import type { Snapshot as NativeSnapshot } from "../snapshots.js";
+import { CompatibilityError, type ClientOptions, type RefusedAsync } from "../compat/core.js";
+export { CompatibilityError };
+/** Morph's base image; on Runtime, the default image. */
+export declare const MORPH_DEFAULT_IMAGE = "morphvm-minimal";
+export declare enum SnapshotStatus {
+    PENDING = "pending",
+    READY = "ready",
+    FAILED = "failed",
+    DELETING = "deleting",
+    DELETED = "deleted"
+}
+export declare enum InstanceStatus {
+    PENDING = "pending",
+    READY = "ready",
+    PAUSED = "paused",
+    SAVING = "saving",
+    ERROR = "error"
+}
+export interface ResourceSpec {
+    vcpus: number;
+    /** MiB. */
+    memory: number;
+    /** MiB. */
+    diskSize: number;
+}
+export interface SnapshotRefs {
+    imageId: string;
+}
+export interface InstanceHttpService {
+    name: string;
+    port: number;
+    url: string;
+}
+export interface InstanceNetworking {
+    internalIp?: string;
+    httpServices: InstanceHttpService[];
+    auth_mode?: string;
+}
+export interface InstanceRefs {
+    snapshotId: string;
+    imageId: string;
+}
+export interface InstanceExecResponse {
+    exit_code: number;
+    stdout: string;
+    stderr: string;
+}
+export interface InstanceTTL {
+    ttlSeconds?: number;
+    ttlExpireAt?: number;
+    ttlAction?: "stop" | "pause";
+}
+export interface InstanceWakeOn {
+    wakeOnSsh?: boolean;
+    wakeOnHttp?: boolean;
+}
+export interface ExecOptions {
+    /** Seconds; default 24 hours, as Morph's. */
+    timeout?: number;
+    onStdout?: (content: string) => void;
+    onStderr?: (content: string) => void;
+}
+export interface InstanceSshKey {
+    object: "instance_ssh_key";
+    private_key: string;
+    public_key: string;
+    password: string;
+}
+export interface MorphCloudClientOptions extends ClientOptions {
+    /** A Runtime key (`rtcloud_...`); a Morph key is never sent anywhere. */
+    apiKey?: string;
+    baseUrl?: string;
+    verbose?: boolean;
+}
+export type ImageListOptions = Record<string, never>;
+export interface SnapshotListOptions {
+    digest?: string;
+    metadata?: Record<string, string>;
+}
+export interface SnapshotCreateOptions {
+    imageId?: string;
+    vcpus?: number;
+    memory?: number;
+    diskSize?: number;
+    digest?: string;
+    metadata?: Record<string, string>;
+}
+export interface SnapshotGetOptions {
+    snapshotId: string;
+}
+export interface InstanceListOptions {
+    metadata?: Record<string, string>;
+}
+export interface InstanceStartOptions {
+    snapshotId: string;
+    metadata?: Record<string, string>;
+    ttlSeconds?: number;
+    ttlAction?: "stop" | "pause";
+    /** Seconds to wait until it runs. */
+    timeout?: number;
+}
+export interface InstanceSnapshotOptions {
+    digest?: string;
+    metadata?: Record<string, string>;
+}
+export interface InstanceGetOptions {
+    instanceId: string;
+}
+export interface InstanceStopOptions {
+    instanceId: string;
+}
+export interface InstanceBootOptions {
+    snapshotId: string;
+    vcpus?: number;
+    memory?: number;
+    diskSize?: number;
+    metadata?: Record<string, string>;
+    ttlSeconds?: number;
+    ttlAction?: "stop" | "pause";
+}
+export interface SyncOptions {
+    delete?: boolean;
+    dryRun?: boolean;
+    verbose?: boolean;
+    respectGitignore?: boolean;
+}
+export declare class Image {
+    readonly id: string;
+    readonly name: string;
+    readonly diskSize: number;
+    readonly created: number;
+    readonly description?: string | undefined;
+    readonly object: "image";
+    constructor(id: string, name: string, diskSize: number, created: number, description?: string | undefined);
+}
+export declare class Snapshot {
+    #private;
+    readonly native: NativeSnapshot;
+    readonly id: string;
+    readonly object: "snapshot";
+    readonly created: number;
+    readonly status: SnapshotStatus;
+    readonly spec: ResourceSpec;
+    readonly refs: SnapshotRefs;
+    readonly digest?: string;
+    metadata?: Record<string, string>;
+    constructor(native: NativeSnapshot, morph: MorphCloudClient);
+    delete(): Promise<void>;
+    /** Morph's chain hash: SHA-256 of the parent's hash, a newline and the effect. */
+    static computeChainHash(parentChainHash: string, effectIdentifier: string): string;
+    /** Runs `command` on a copy of this snapshot and snapshots the result, once:
+     * a later setup of the same command on the same snapshot answers the
+     * snapshot made the first time. A command that fails throws, and the copy
+     * is stopped either way. */
+    setup(command: string): Promise<Snapshot>;
+    /** Adds or changes these metadata keys; the others stay. */
+    setMetadata(metadata: Record<string, string>): Promise<void>;
+}
+export declare class Instance {
+    #private;
+    readonly id: string;
+    readonly object: "instance";
+    readonly created: number;
+    status: InstanceStatus;
+    readonly spec: ResourceSpec;
+    readonly refs: InstanceRefs;
+    networking: InstanceNetworking;
+    ttl: InstanceTTL;
+    wakeOn: InstanceWakeOn;
+    metadata?: Record<string, string>;
+    readonly ssh: RefusedAsync;
+    readonly sshKey: RefusedAsync;
+    readonly sshKeyRotate: RefusedAsync;
+    readonly reboot: RefusedAsync;
+    readonly setTTL: RefusedAsync;
+    constructor(sandbox: Sandbox, morph: MorphCloudClient, previews?: Preview[]);
+    /** The Runtime sandbox behind it, for what Morph has no call for. */
+    get native(): Sandbox;
+    /** Deletes it, with its disk and memory, as Morph's stop does; its snapshots stay. */
+    stop(): Promise<void>;
+    /** Keeps memory and disk, and stops compute charges. */
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    /** Adds or changes these metadata keys; the others stay. */
+    setMetadata(metadata: Record<string, string>): Promise<void>;
+    /** Runtime wakes a paused sandbox on any request (an API call, SSH, a
+     * visit to a shared port) or on none: both values must agree. */
+    setWakeOn(wakeOnSsh?: boolean, wakeOnHttp?: boolean): Promise<void>;
+    /** Files, memory and running processes; a running instance pauses for the
+     * moment it takes, then runs on. */
+    snapshot(options?: InstanceSnapshotOptions): Promise<Snapshot>;
+    /** `count` running copies, with its files, memory and processes, and the
+     * snapshot they were started from, which is kept. */
+    branch(count: number): Promise<{
+        snapshot: Snapshot;
+        instances: Instance[];
+    }>;
+    /** Shares `port` at an HTTPS address. With no auth_mode, anyone with the
+     * address reaches it (Runtime's public preview, which needs a kept
+     * top-up); with auth_mode "api_key", a request needs the preview's token
+     * in `x-runtime-preview-token` (native.previews.get(port)). */
+    exposeHttpService(name: string, port: number, auth_mode?: string): Promise<InstanceHttpService>;
+    hideHttpService(name: string): Promise<void>;
+    /** A string, or a one-item array, runs in a shell; a longer array runs as
+     * its arguments. Output streams to onStdout and onStderr as it comes. */
+    exec(command: string | string[], options?: ExecOptions): Promise<InstanceExecResponse>;
+    /** Seconds; waits until it runs, waking it if paused. */
+    waitUntilReady(timeout?: number): Promise<void>;
+    /** Copies a local file or folder into the instance, or out of it: the
+     * instance's side is written `<instance id>:<path>`. Without delete, dry
+     * runs or .gitignore, which refuse. */
+    sync(source: string, dest: string, options?: SyncOptions): Promise<void>;
+}
+/** Morph's client, on Runtime. `new MorphCloudClient()` reads RUNTIME_API_KEY
+ * (or a saved login), never MORPH_API_KEY. */
+export declare class MorphCloudClient {
+    readonly runtime: Runtime;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly verbose: boolean;
+    readonly GET: RefusedAsync;
+    readonly POST: RefusedAsync;
+    readonly streamPOST: RefusedAsync;
+    readonly DELETE: RefusedAsync;
+    constructor(options?: MorphCloudClientOptions);
+    images: {
+        /** Morph's base image, which is Runtime's default image. Build others with runtime.images. */
+        list: (_options?: ImageListOptions) => Promise<Image[]>;
+    };
+    snapshots: {
+        list: (options?: SnapshotListOptions) => Promise<Snapshot[]>;
+        /** A bootable snapshot of an image at a size: Runtime boots a sandbox from
+         * the image, snapshots its disk and stops it. With a digest, a snapshot
+         * already made with it is answered instead. */
+        create: (options?: SnapshotCreateOptions) => Promise<Snapshot>;
+        get: (options: SnapshotGetOptions) => Promise<Snapshot>;
+    };
+    instances: {
+        /** Running and paused instances whose metadata match. */
+        list: (options?: InstanceListOptions) => Promise<Instance[]>;
+        /** A running copy of a snapshot: files, and memory and processes when the
+         * snapshot kept them. */
+        start: (options: InstanceStartOptions) => Promise<Instance>;
+        /** As start; a different vcpus or memory restarts it at that size (its
+         * files kept, its programs started afresh). The disk keeps the snapshot's size. */
+        boot: (options: InstanceBootOptions) => Promise<Instance>;
+        get: (options: InstanceGetOptions) => Promise<Instance>;
+        /** Deletes it, with its disk and memory, as Morph's stop does; its snapshots stay. */
+        stop: (options: InstanceStopOptions) => Promise<void>;
+    };
+}