withruntime 0.8.4 → 0.10.0

package/dist/vercel/sandbox.js

@@ -36,6 +36,10 @@ function leaseSeconds(timeoutMs) {
     return Math.max(seconds, MIN_LEASE_SECONDS);
 }
 function refuseCreate(params) {
+    if (params.keepLastSnapshots !== undefined)
+        throw new NotSupportedError("Snapshot count and eviction policies (keepLastSnapshots)", "Omit it; manage saved snapshots explicitly with Snapshot.list and snapshot.delete.");
+    if (params.ports !== undefined)
+        validatePorts(params.ports);
     if (params.mounts && Object.keys(params.mounts).length)
         throw new NotSupportedError("Vercel Drives (mounts)", "Use a Runtime volume: withruntime: { create: { volumes: [{ volumeId, path }] } } (runtime.volumes creates one).");
     if (params.networkId !== undefined)
@@ -45,6 +49,11 @@ function refuseCreate(params) {
     if (params.failoverRegions?.length)
         throw new NotSupportedError("Failover regions (failoverRegions)", "Remove it: Runtime runs in one US region.");
 }
+function validatePorts(ports) {
+    if (!Array.isArray(ports) ||
+        ports.some((port) => !Number.isSafeInteger(port) || port < 1 || port > 65_535))
+        throw new RangeError("ports must contain only integers from 1 to 65535.");
+}
 /** Vercel's network policy as Runtime's rules. Header injection and
  * forwarding rules have no Runtime counterpart and are refused. */
 export function networkRules(policy) {
@@ -111,15 +120,15 @@ function statusOf(state) {
 /** Runtime's `/workspace` stands for Vercel's `/vercel/sandbox`: relative
  * paths resolve against it, and paths under /vercel/sandbox are rewritten. */
 export function toRuntimePath(path, cwd) {
-    const base = cwd === undefined ? HOME : toVercelPath(cwd);
-    const absolute = path.startsWith("/") ? path : `${base}/${path.replace(/^\.\/?/, "")}`;
+    const base = cwd === undefined ? HOME : toVercelPath(cwd).replace(/\/+$/, "");
+    const absolute = path.startsWith("/") ? path : `${base}/${path.replace(/^(?:\.(?:\/+|$))+/, "")}`;
     const normal = absolute.replace(/\/+$/, "") || "/";
     if (normal === HOME || normal.startsWith(`${HOME}/`))
         return RUNTIME_HOME + normal.slice(HOME.length);
     return normal;
 }
 function toVercelPath(path) {
-    return path.startsWith("/") ? path : `${HOME}/${path.replace(/^\.\/?/, "")}`;
+    return path.startsWith("/") ? path : `${HOME}/${path.replace(/^(?:\.(?:\/+|$))+/, "")}`;
 }
 /** A sandbox with Vercel's methods. `sandbox.withruntime` is the Runtime
  * sandbox underneath, for anything Vercel has no name for. */
@@ -143,9 +152,9 @@ export class Sandbox {
         this.fs = new FileSystem({
             name: this.name,
             files: async () => (await this.#live()).files,
-            run: async (argv) => {
+            run: async (argv, options) => {
                 const live = await this.#live();
-                return live.exec(argv);
+                return live.exec(argv, options);
             },
             resolve: (path, cwd) => toRuntimePath(path, cwd),
         });
@@ -227,6 +236,8 @@ export class Sandbox {
         refuseCreate(params);
         const client = clientFor(params);
         const persistent = params.persistent ?? true;
+        if (params.snapshotExpiration !== undefined && persistent)
+            retentionDays(params.snapshotExpiration);
         const vcpus = params.resources?.vcpus ?? DEFAULT_VCPUS;
         const source = await guard(() => resolveImage(client, params));
         const input = {
@@ -300,15 +311,16 @@ export class Sandbox {
     /** A sandbox by name (or Runtime id), woken if it is paused unless
      * `resume: false`. */
     static async get(params) {
+        params.signal?.throwIfAborted();
         const client = clientFor(params);
-        const runtime = await guard(() => find(client, params.name), params.name);
+        const runtime = await guard(() => find(client, params.name, params), params.name);
         const sandbox = new Sandbox({
             runtime,
             client,
             params: params.onResume ? { onResume: params.onResume } : {},
         });
         if (params.resume !== false)
-            await sandbox.#live();
+            await sandbox.#live(params);
         return sandbox;
     }
     /** The named sandbox, or a new one with that name when there is none. */
@@ -329,9 +341,22 @@ export class Sandbox {
     /** A new sandbox copied from a running one, memory and all (a Runtime
      * fork). `sourceSandbox` is its name. */
     static async fork(params) {
-        const unsupported = ["resources", "ports", "timeout", "networkPolicy", "image", "tags", "env"].find((field) => params[field] !== undefined);
+        const unsupported = [
+            "resources",
+            "ports",
+            "timeout",
+            "networkPolicy",
+            "image",
+            "tags",
+            "env",
+            "persistent",
+            "snapshotExpiration",
+            "keepLastSnapshots",
+            "onResume",
+            "runtime",
+        ].find((field) => params[field] !== undefined);
         if (unsupported)
-            throw new NotSupportedError(`Overriding ${unsupported} on a fork`, "Fork without it; the copy keeps the source's machine, lease and rules.");
+            throw new NotSupportedError(`Overriding ${unsupported} on a fork`, "Omit the override to use Runtime's existing fork behavior.");
         refuseCreate(params);
         const source = await Sandbox.get({ ...params, name: params.sourceSandbox });
         const copy = await guard(() => source.#rt.fork({ ...(params.name ? { name: params.name } : {}), ...signalOf(params) }), params.sourceSandbox);
@@ -344,6 +369,7 @@ export class Sandbox {
     /** Running and stopped (paused) sandboxes, oldest first, with Vercel's
      * paginator: `for await (const s of await Sandbox.list())`. */
     static async list(params = {}) {
+        params.signal?.throwIfAborted();
         for (const field of ["since", "until", "cursor", "sortBy", "sortOrder", "namePrefix"])
             if (params[field] !== undefined)
                 throw new NotSupportedError(`Listing sandboxes by ${field}`, "List them all (oldest first) and filter the result yourself.");
@@ -351,13 +377,14 @@ export class Sandbox {
         const page = await guard(() => client.sandboxes.list({
             ...(params.tags ? { labels: params.tags } : {}),
             ...(params.limit ? { limit: Math.min(params.limit, 100) } : {}),
-        }));
-        return paginate(page);
+        }, signalOf(params)));
+        return paginate(page, params.signal);
     }
     // ---- commands ---------------------------------------------------------
     /** Wakes the sandbox if it was paused (a stopped persistent sandbox, in
      * Vercel's words), as Vercel resumes one on the next call. */
-    async #live() {
+    async #live(opts = {}) {
+        opts.signal?.throwIfAborted();
         if (this.#deleted)
             throw new APIError(new Response(null, { status: 410 }), {
                 message: `Sandbox ${this.name} was deleted.`,
@@ -365,35 +392,43 @@ export class Sandbox {
             });
         const state = this.#rt.state;
         if (state === "paused" || state === "pausing")
-            await this.#wake();
+            await this.#wake(opts);
         return this.#rt;
     }
-    async #wake() {
-        await guard(() => this.#rt.wake({}), this.name);
+    async #wake(opts = {}) {
+        await guard(() => this.#rt.wake(signalOf(opts)), this.name);
         await this.#onResume?.(this);
     }
     /** Runs `work` on the live sandbox; if the lease paused it meanwhile, wakes
      * it and runs `work` once more. */
-    async #withResume(work) {
-        const runtime = await this.#live();
+    async #withResume(work, opts = {}) {
+        opts.signal?.throwIfAborted();
+        const runtime = await this.#live(opts);
         try {
             return await work(runtime);
         }
         catch (error) {
             if (!(error instanceof RuntimeError && error.code === "sandbox_paused"))
                 throw translate(error, this.name);
-            await guard(() => runtime.refresh(), this.name);
-            await this.#wake();
+            await guard(() => runtime.refresh(signalOf(opts)), this.name);
+            await this.#wake(opts);
             return guard(() => work(this.#rt), this.name);
         }
     }
-    async #linkHome(text) {
+    async #linkHome(text, opts = {}) {
+        opts.signal?.throwIfAborted();
         if (this.#linked || !text.includes(HOME))
             return this.#linked;
         this.#linked = (async () => {
-            await this.#rt.exec(HOME_LINK).catch(() => undefined);
+            await this.#rt.exec(HOME_LINK, signalOf(opts)).catch(() => opts.signal?.throwIfAborted());
         })();
-        return this.#linked;
+        try {
+            await this.#linked;
+        }
+        catch (error) {
+            this.#linked = undefined;
+            throw error;
+        }
     }
     async runCommand(commandOrParams, args, opts = {}) {
         const params = typeof commandOrParams === "string"
@@ -406,18 +441,19 @@ export class Sandbox {
         ];
         const cwd = params.cwd === undefined ? RUNTIME_HOME : toRuntimePath(params.cwd);
         const env = { ...this.#env, ...params.env };
-        await this.#live();
-        await this.#linkHome(`${argv.join(" ")}\n${params.cwd ?? ""}\n${Object.values(env).join("\n")}`);
+        await this.#live(params);
+        await this.#linkHome(`${argv.join(" ")}\n${params.cwd ?? ""}\n${Object.values(env).join("\n")}`, params);
         const timeoutMs = params.timeoutMs ?? LONGEST_MS;
         const common = {
             cwd,
             ...(Object.keys(env).length ? { env } : {}),
             timeoutMs,
+            ...signalOf(params),
         };
         const startedAt = Date.now();
         const vercelCwd = params.cwd === undefined ? HOME : toVercelPath(params.cwd);
         if (params.detached) {
-            const process = await this.#withResume((runtime) => runtime.spawn(argv, common));
+            const process = await this.#withResume((runtime) => runtime.spawn(argv, common), params);
             const command = new Command({
                 id: process.id,
                 cwd: vercelCwd,
@@ -438,8 +474,7 @@ export class Sandbox {
             ...common,
             onStdout: record("stdout", params.stdout),
             onStderr: record("stderr", params.stderr),
-            ...signalOf(params),
-        }));
+        }), params);
         return new CommandFinished({
             id: result.processId ?? `cmd_${startedAt}`,
             cwd: vercelCwd,
@@ -449,8 +484,8 @@ export class Sandbox {
         }, exitCodeOf(result.exitCode, result.timedOut), result.durationMs ?? Date.now() - startedAt);
     }
     /** A command started earlier, by its cmdId. */
-    async getCommand(cmdId, _opts = {}) {
-        const process = await this.#withResume((runtime) => runtime.processes.get(cmdId));
+    async getCommand(cmdId, opts = {}) {
+        const process = await this.#withResume((runtime) => runtime.processes.get(cmdId, signalOf(opts)), opts);
         return new Command({
             id: process.id,
             cwd: process.info.cwd,
@@ -460,9 +495,9 @@ export class Sandbox {
         });
     }
     // ---- files ------------------------------------------------------------
-    async mkDir(path, _opts = {}) {
+    async mkDir(path, opts = {}) {
         const target = toRuntimePath(path);
-        await this.#withResume((runtime) => runtime.files.mkdir(target, { parents: true }));
+        await this.#withResume((runtime) => runtime.files.mkdir(target, { parents: true, ...signalOf(opts) }), opts);
     }
     /** The file's bytes as a Node stream, or null when there is no file. */
     async readFile(file, opts = {}) {
@@ -476,7 +511,7 @@ export class Sandbox {
     async readFileToBuffer(file, opts = {}) {
         const target = toRuntimePath(file.path, file.cwd);
         try {
-            return Buffer.from(await this.#withResume((runtime) => runtime.files.read(target, signalOf(opts))));
+            return Buffer.from(await this.#withResume((runtime) => runtime.files.read(target, signalOf(opts)), opts));
         }
         catch (error) {
             if (error instanceof APIError && error.response.status === 404)
@@ -489,39 +524,42 @@ export class Sandbox {
         const buffer = await this.readFileToBuffer(src, opts);
         if (buffer === null)
             return null;
+        opts.signal?.throwIfAborted();
         const { mkdir, writeFile } = await import("node:fs/promises");
         const paths = await import("node:path");
         const target = paths.resolve(dst.cwd ?? process.cwd(), dst.path);
+        opts.signal?.throwIfAborted();
         if (opts.mkdirRecursive)
             await mkdir(paths.dirname(target), { recursive: true });
-        await writeFile(target, buffer);
+        await writeFile(target, buffer, signalOf(opts));
         return target;
     }
     /** Writes files, making their directories. Relative paths land in the
      * working directory; `mode` sets permissions. */
-    async writeFiles(files, _opts = {}) {
+    async writeFiles(files, opts = {}) {
         const modes = [];
         await this.#withResume(async (runtime) => {
             for (const file of files) {
                 const target = toRuntimePath(file.path);
-                await runtime.files.write(target, file.content);
+                await runtime.files.write(target, file.content, signalOf(opts));
                 if (file.mode !== undefined)
                     modes.push(file.mode.toString(8), target);
             }
             if (!modes.length)
                 return;
             const script = 'while [ "$#" -gt 0 ]; do chmod "$1" "$2" || exit 1; shift 2; done';
-            const result = await runtime.exec(["sh", "-c", script, "sh", ...modes]);
+            const result = await runtime.exec(["sh", "-c", script, "sh", ...modes], signalOf(opts));
             if (result.exitCode !== 0)
                 throw new APIError(new Response(null, { status: 400 }), {
                     message: `Setting file modes failed: ${result.stderr.trim()}`,
                     sandboxName: this.name,
                 });
-        });
+        }, opts);
     }
     // ---- ports ------------------------------------------------------------
-    async #share(port) {
-        const preview = await guard(() => this.#rt.previews.create(port, { visibility: "public" }), this.name);
+    async #share(port, opts = {}) {
+        opts.signal?.throwIfAborted();
+        const preview = await guard(() => this.#rt.previews.create(port, { visibility: "public" }, signalOf(opts)), this.name);
         this.#routes.set(port, preview.url.replace(/\/$/, ""));
     }
     /** The public address of a port listed in `ports`, such as
@@ -566,53 +604,99 @@ export class Sandbox {
     async extendTimeout(duration, opts = {}) {
         if (!Number.isFinite(duration) || duration <= 0)
             throw new RangeError(`duration must be a positive number of milliseconds, not ${duration}.`);
-        await this.#withResume((runtime) => runtime.extend(Math.ceil(duration / 1000), signalOf(opts)));
+        await this.#withResume((runtime) => runtime.extend(Math.ceil(duration / 1000), signalOf(opts)), opts);
     }
     /** Replaces the network rules; returns the policy given. */
-    async updateNetworkPolicy(networkPolicy, _opts = {}) {
+    async updateNetworkPolicy(networkPolicy, opts = {}) {
+        opts.signal?.throwIfAborted();
         const rules = networkRules(networkPolicy);
-        await this.#withResume((runtime) => runtime.network.set(rules));
+        await this.#withResume((runtime) => runtime.network.set(rules, signalOf(opts)), opts);
         return networkPolicy;
     }
     /** Changes what Runtime can change on a sandbox: `timeout`, `ports`,
      * `networkPolicy` and `snapshotExpiration`. Anything else is refused before
      * anything changes. */
-    async update(params, _opts = {}) {
+    async update(params, opts = {}) {
+        opts.signal?.throwIfAborted();
         const allowed = new Set(["timeout", "ports", "networkPolicy", "snapshotExpiration"]);
         const other = Object.keys(params).find((key) => params[key] !== undefined && !allowed.has(key));
         if (other)
             throw new NotSupportedError(`Changing ${other} on an existing sandbox`, "Create a new sandbox with it (Runtime cannot change a sandbox's machine, persistence, tags or region after creation).");
+        const rules = params.networkPolicy === undefined ? undefined : networkRules(params.networkPolicy);
+        const retention = params.snapshotExpiration === undefined
+            ? undefined
+            : retentionDays(params.snapshotExpiration);
+        if (params.ports !== undefined)
+            validatePorts(params.ports);
+        const wanted = params.ports === undefined ? undefined : new Set(params.ports);
         if (params.timeout !== undefined) {
             const current = this.timeout;
             if (params.timeout < current)
                 throw new NotSupportedError("Shortening a sandbox's timeout", "Runtime leases only move later. Call stop() when the work is done.");
             if (params.timeout > current)
-                await this.extendTimeout(params.timeout - current);
+                await this.extendTimeout(params.timeout - current, opts);
         }
-        if (params.networkPolicy !== undefined)
-            await this.updateNetworkPolicy(params.networkPolicy);
-        if (params.snapshotExpiration !== undefined)
-            await guard(() => this.#rt.setRetention(retentionDays(params.snapshotExpiration)), this.name);
-        if (params.ports !== undefined) {
-            const wanted = new Set(params.ports);
+        if (rules !== undefined)
+            await this.#withResume((runtime) => runtime.network.set(rules, signalOf(opts)), opts);
+        if (retention !== undefined)
+            await guard(() => this.#rt.setRetention(retention, signalOf(opts)), this.name);
+        if (wanted !== undefined) {
             for (const port of [...this.#routes.keys()])
                 if (!wanted.has(port)) {
-                    await guard(() => this.#rt.previews.delete(port), this.name);
+                    await guard(() => this.#rt.previews.delete(port, signalOf(opts)), this.name);
                     this.#routes.delete(port);
                 }
             for (const port of wanted)
                 if (!this.#routes.has(port))
-                    await this.#share(port);
+                    await this.#share(port, opts);
         }
     }
-    /** Keeps the sandbox's whole machine as a Runtime snapshot (files, memory
-     * and running processes), then stops the sandbox, as Vercel does. Start
+    /** Keeps the sandbox's filesystem as a disk-only snapshot, then stops
+     * the source. Restoring it starts fresh processes, as Vercel does. Start
      * from it with `Sandbox.create({ source: { type: "snapshot", snapshotId } })`. */
     async snapshot(opts = {}) {
+        opts.signal?.throwIfAborted();
+        const retention = opts.expiration === undefined ? undefined : retentionDays(opts.expiration);
         const taken = await this.#withResume((runtime) => runtime.snapshot({
-            ...(opts.expiration !== undefined ? { retentionDays: retentionDays(opts.expiration) } : {}),
-        }));
-        await guard(() => this.#rt.stop({ wait: false }), this.name);
+            mode: "disk",
+            ...(retention !== undefined ? { retentionDays: retention } : {}),
+            ...signalOf(opts),
+        }), opts);
+        try {
+            await guard(() => this.#rt.stop(signalOf(opts)), this.name);
+            if (this.#rt.state !== "stopped")
+                await guard(() => this.#rt.waitFor("stopped", signalOf(opts)), this.name);
+        }
+        catch (error) {
+            const recovery = { snapshotId: taken.id, sourceSandboxId: this.#rt.id };
+            if (error instanceof APIError) {
+                const json = error.json;
+                error.json = {
+                    ...json,
+                    error: {
+                        ...json?.error,
+                        details: { ...(json?.error?.details ?? {}), ...recovery },
+                    },
+                };
+            }
+            else if (error instanceof Error && Object.isExtensible(error)) {
+                Object.assign(error, recovery);
+            }
+            throw error;
+        }
+        if (this.#rt.state !== "stopped") {
+            const code = "snapshot_source_stop_timeout";
+            const message = `Snapshot ${taken.id} was saved, but sandbox ${this.name} did not finish stopping.`;
+            const error = new APIError(new Response(null, { status: 409 }), {
+                message,
+                sandboxName: this.name,
+                json: {
+                    error: { code, message, details: { snapshotId: taken.id, sourceSandboxId: this.#rt.id } },
+                },
+            });
+            error.code = code;
+            throw error;
+        }
         return new Snapshot(taken, this.#client);
     }
     // ---- what Runtime does differently -----------------------------------
@@ -656,6 +740,8 @@ function usersRefused() {
 /** Milliseconds as whole days for Runtime's retention: 1 to 365, and 0 (no
  * expiration) as 365. */
 export function retentionDays(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        throw new RangeError(`Snapshot expiration must be a nonnegative finite number of milliseconds, not ${ms}.`);
     if (ms === 0)
         return 365;
     return Math.min(365, Math.max(1, Math.ceil(ms / 86_400_000)));
@@ -671,11 +757,13 @@ async function pipe(command, params) {
 }
 /** The newest live sandbox with this name, or the sandbox with this Runtime
  * id. A 404 when there is none. */
-async function find(client, name) {
+async function find(client, name, opts = {}) {
+    opts.signal?.throwIfAborted();
     if (UUID.test(name))
-        return client.sandboxes.get(name);
-    const page = await client.sandboxes.list({ name });
+        return client.sandboxes.get(name, signalOf(opts));
+    const page = await client.sandboxes.list({ name }, signalOf(opts));
     const all = await page.toArray(1000);
+    opts.signal?.throwIfAborted();
     const found = all.filter((one) => one.state !== "stopped").at(-1);
     if (!found)
         throw new RuntimeError({
@@ -705,22 +793,29 @@ function itemOf(runtime) {
 }
 /** Vercel's paginator over a Runtime page: the first page's fields, async
  * iteration over every item, `pages()` and `toArray()`. */
-function paginate(first) {
+function paginate(first, signal) {
     const toPage = (page) => ({
         sandboxes: page.data.map(itemOf),
         pagination: { count: page.data.length, next: page.nextCursor },
     });
     return Object.assign(toPage(first), {
         async *pages() {
-            for await (const page of first.pages())
+            for await (const page of first.pages()) {
+                signal?.throwIfAborted();
                 yield toPage(page);
+            }
         },
         async *[Symbol.asyncIterator]() {
-            for await (const item of first)
+            for await (const item of first) {
+                signal?.throwIfAborted();
                 yield itemOf(item);
+            }
         },
         async toArray() {
-            return (await first.toArray()).map(itemOf);
+            signal?.throwIfAborted();
+            const items = await first.toArray();
+            signal?.throwIfAborted();
+            return items.map(itemOf);
         },
     });
 }

package/dist/vercel/snapshot.d.ts

@@ -2,8 +2,8 @@ import type { Runtime } from "../client.js";
 import type { Snapshot as RuntimeSnapshot } from "../snapshots.js";
 import { type Credentials, type WithRuntime } from "./client.js";
 type Status = "created" | "failed" | "deleted";
-/** A saved sandbox, as Vercel's Snapshot, over a Runtime snapshot: files,
- * memory and running processes. `sourceSessionId` is the Runtime id of the
+/** A saved filesystem, as Vercel's Snapshot, over a Runtime disk snapshot.
+ * Restoring it starts fresh processes. `sourceSessionId` is the Runtime id of the
  * sandbox it came from. */
 export declare class Snapshot {
     #private;
@@ -26,6 +26,7 @@ export declare class Snapshot {
     static list(params?: {
         name?: string;
         limit?: number;
+        signal?: AbortSignal;
     } & Credentials & {
         withruntime?: WithRuntime;
     } & Record<string, unknown>): Promise<{

package/dist/vercel/snapshot.js

@@ -20,8 +20,8 @@ function metadataOf(snapshot) {
         expiresAt: Date.parse(snapshot.expiresAt),
     };
 }
-/** A saved sandbox, as Vercel's Snapshot, over a Runtime snapshot: files,
- * memory and running processes. `sourceSessionId` is the Runtime id of the
+/** A saved filesystem, as Vercel's Snapshot, over a Runtime disk snapshot.
+ * Restoring it starts fresh processes. `sourceSessionId` is the Runtime id of the
  * sandbox it came from. */
 export class Snapshot {
     #snapshot;
@@ -60,13 +60,14 @@ export class Snapshot {
     }
     /** Snapshots, oldest first; `name` narrows to one sandbox's. */
     static async list(params = {}) {
+        params.signal?.throwIfAborted();
         for (const field of ["since", "until", "cursor", "sortOrder"])
             if (params[field] !== undefined)
                 throw new NotSupportedError(`Listing snapshots by ${field}`, "List them all and filter the result yourself.");
         const client = clientFor(params);
         let sandboxId;
         if (params.name !== undefined) {
-            const found = (await guard(() => client.sandboxes.list({ name: params.name, includeStopped: true }))).data[0];
+            const found = (await guard(() => client.sandboxes.list({ name: params.name, includeStopped: true }, signalOf(params)))).data[0];
             if (!found)
                 return paginate([], null);
             sandboxId = found.id;
@@ -74,7 +75,7 @@ export class Snapshot {
         const page = await guard(() => client.snapshots.list({
             ...(sandboxId ? { sandboxId } : {}),
             ...(params.limit ? { limit: params.limit } : {}),
-        }));
+        }, signalOf(params)));
         return paginate(page.data, page.nextCursor, page);
     }
     static tree() {
@@ -83,10 +84,13 @@ export class Snapshot {
     async delete(opts = {}) {
         try {
             await guard(() => this.#client.snapshots.delete(this.#snapshot.id, signalOf(opts)));
+            Object.assign(this.#snapshot, await guard(() => this.#client.snapshots.get(this.#snapshot.id, signalOf(opts))));
         }
         catch (error) {
-            if (error instanceof APIError && error.response.status === 404)
+            if (error instanceof APIError && error.response.status === 404) {
+                this.#snapshot.state = "deleted";
                 return;
+            }
             throw error;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "withruntime",
-  "version": "0.8.4",
+  "version": "0.10.0",
   "license": "Apache-2.0",
   "mcpName": "com.withruntime/runtime",
   "type": "module",
@@ -59,6 +59,41 @@
       "types": "./dist/ai-harness/index.d.ts",
       "import": "./dist/ai-harness/index.js",
       "default": "./dist/ai-harness/index.js"
+    },
+    "./runloop": {
+      "types": "./dist/runloop/index.d.ts",
+      "import": "./dist/runloop/index.js",
+      "default": "./dist/runloop/index.js"
+    },
+    "./codesandbox": {
+      "types": "./dist/codesandbox/index.d.ts",
+      "import": "./dist/codesandbox/index.js",
+      "default": "./dist/codesandbox/index.js"
+    },
+    "./sprites": {
+      "types": "./dist/sprites/index.d.ts",
+      "import": "./dist/sprites/index.js",
+      "default": "./dist/sprites/index.js"
+    },
+    "./freestyle": {
+      "types": "./dist/freestyle/index.d.ts",
+      "import": "./dist/freestyle/index.js",
+      "default": "./dist/freestyle/index.js"
+    },
+    "./modal": {
+      "types": "./dist/modal/index.d.ts",
+      "import": "./dist/modal/index.js",
+      "default": "./dist/modal/index.js"
+    },
+    "./cloudflare": {
+      "workerd": {
+        "types": "./dist/cloudflare/worker.d.ts",
+        "import": "./dist/cloudflare/worker.js",
+        "default": "./dist/cloudflare/worker.js"
+      },
+      "types": "./dist/cloudflare/index.d.ts",
+      "import": "./dist/cloudflare/index.js",
+      "default": "./dist/cloudflare/index.js"
     }
   },
   "bin": {
@@ -72,7 +107,9 @@
     "DAYTONA.md",
     "VERCEL.md",
     "BLAXEL.md",
-    "LICENSE"
+    "LICENSE",
+    "COMPATIBILITY.md",
+    "compatibility-lock.json"
   ],
   "engines": {
     "node": ">=22.12"
@@ -86,12 +123,17 @@
     "test:java": "bun ../../sdks/java/scripts/check.ts",
     "test:ruby": "bun ../../sdks/ruby/scripts/check.ts",
     "test:python": "bun scripts/test-python.ts",
-    "test:go": "bun scripts/test-go.ts"
+    "test:go": "bun scripts/test-go.ts",
+    "compat:upstream": "bun scripts/check-upstream.ts",
+    "test:compat": "bun test tests/e2b tests/daytona tests/vercel tests/blaxel tests/compat tests/drop-in-isolation.test.ts tests/drop-in-paths.test.ts tests/process-input.test.ts tests/watch-reentrant.test.ts tests/upstream-check.test.ts tests/process-output.test.ts tests/prepare-compatibility.test.ts",
+    "compat:prepare": "bun scripts/prepare-compatibility.ts",
+    "compat:oracle": "bun oracle/check.mjs"
   },
   "devDependencies": {
     "@ai-sdk/harness": "1.0.124",
     "@anthropic-ai/claude-agent-sdk": "0.3.277",
     "@anthropic-ai/sdk": "0.128.0",
+    "@cloudflare/workers-types": "5.20260929.1",
     "@google/genai": "2.24.0",
     "@mastra/core": "1.71.0",
     "@mistralai/mistralai": "2.7.0",
@@ -127,6 +169,7 @@
   "bugs": "https://github.com/withruntime/runtime/issues",
   "sideEffects": false,
   "browser": {
+    "./dist/file-source.js": "./dist/browser-stub.js",
     "./dist/tar.js": "./dist/browser-stub.js",
     "./dist/image-context.js": "./dist/browser-stub.js",
     "./dist/credentials.js": "./dist/browser-stub.js",