withruntime 0.11.1 → 0.11.2

package/dist/client.d.ts

@@ -1,11 +1,11 @@
-import { RuntimeError } from "./errors.js";
-import type { Page } from "./page.js";
 import { type ClientExtensions } from "./products/index.js";
 import { usageExport as makeUsageExport } from "./products/observability.js";
+import { Machines } from "./machine.js";
 import { Sandbox } from "./sandbox.js";
 import { Snapshots } from "./snapshots.js";
 import { Transport, type RequestOptions } from "./transport.js";
 import type { CreateSandbox, DeletedSandbox, FeedbackKind, SandboxInfo, Usage } from "./types.js";
+export type { CreateOptions } from "./machine.js";
 export type RuntimeOptions = {
     /** Default: the RUNTIME_API_KEY environment variable. */
     apiKey?: string;
@@ -22,9 +22,12 @@ export type RuntimeOptions = {
      * before it has used a valid key. 8 are kept for calls whatever the
      * streams hold. */
     maxConnections?: number;
+    /** Called each time a call has to wait for one of those connections: an
+     * adapter warns with it, once, that its caller is being held back. */
+    onQueued?: (maxConnections: number) => void;
     /** How long `sandboxes.create` keeps retrying, with the same key and input,
-     * when the trial's slots, the account's quota or the region is full
-     * (trial_busy, quota_exceeded, no_capacity and the like). Default 120 000
+     * when the slots without credit, the account's quota or the region is full
+     * (no_credit_running_limit, quota_exceeded, no_capacity and the like). Default 120 000
      * (two minutes); 0 fails at once. The refusal is thrown as it came when the
      * wait runs out. */
     waitForCapacityMs?: number;
@@ -57,8 +60,8 @@ export declare class Runtime {
         /** The role of the member who made this key: owner, admin, developer or billing. */
         role?: string | null;
     }>;
-    /** Balance, holds, trial time and per-resource charges, in integer microdollars. */
-    /** Credit, holds, trial time and per-resource charges. */
+    /** Balance, holds, free time and per-resource charges, in integer microdollars. */
+    /** Credit, holds, free time and per-resource charges. */
     usage(options?: RequestOptions): Promise<Usage>;
     /** This account's authenticated API answers, in hourly windows. Counts are
      * exact decimal strings, and an empty window has a null error percentage.
@@ -80,60 +83,9 @@ export declare class Runtime {
         }>;
     }>;
 }
-/** How `sandboxes.create` waits when every trial slot, the account's quota or
- * the region is full. */
-export type CreateOptions = RequestOptions & {
-    /** How long to keep retrying a refusal that clears by itself. 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: to tell a person why nothing has happened yet. */
-    onCapacityWait?: (refusal: RuntimeError, waitMs: number) => void;
-};
-export declare class Sandboxes {
-    private readonly t;
+/** `runtime.sandboxes`: the sandbox product of the machine engine. */
+export declare class Sandboxes extends Machines<Sandbox, SandboxInfo, CreateSandbox, DeletedSandbox> {
     constructor(t: Transport);
-    /** Creates a sandbox and waits until it is running. Every field is optional:
-     * with none you get the free trial while it lasts, the default region and a
-     * 2 vCPU / 4 GiB machine from a warm template. `wait: false` returns at once.
-     * When every trial slot or the account's quota is taken, it waits for one to
-     * free, up to `waitForCapacityMs` (the client's, two minutes by default). */
-    create(input?: CreateSandbox & {
-        wait?: boolean;
-    }, options?: CreateOptions): Promise<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. */
-    getOrCreate(name: string, input?: Omit<CreateSandbox, "name" | "getOrCreate"> & {
-        wait?: boolean;
-    }, options?: CreateOptions): Promise<Sandbox>;
-    get(id: string, options?: RequestOptions): Promise<Sandbox>;
-    /** Deletes a sandbox for good, by id, without reading it first: see
-     * `sandbox.delete()`. Deleting it again answers the same. */
-    delete(id: string, options?: RequestOptions): Promise<DeletedSandbox>;
-    /** Live sandboxes, oldest first. Await for a page, or `for await` over all.
-     * Request options apply to the initial request and every subsequent page. */
-    list(filter?: {
-        state?: SandboxInfo["state"][];
-        includeStopped?: boolean;
-        /** Every label must match. */
-        labels?: Record<string, string>;
-        name?: string;
-        limit?: number;
-    }, options?: RequestOptions): Promise<Page<Sandbox>>;
-    /** Stops every live sandbox whose labels all match, eight at a time, and
-     * says which stopped and which failed; one failure does not stop the rest.
-     * Needs at least one label, so stopping everything is never one call. */
-    stopAll(filter: {
-        labels: Record<string, string>;
-    }, options?: RequestOptions): Promise<{
-        stopped: string[];
-        failed: {
-            id: string;
-            error: unknown;
-        }[];
-    }>;
 }
 export declare class FeedbackApi {
     private readonly t;

package/dist/client.js

@@ -1,8 +1,7 @@
-import { WAIT_FOR_TIMEOUT_SECONDS } from "./api-defaults.js";
-import { RuntimeError } from "./errors.js";
 import { clientFactories, clientProductAliases } from "./products/index.js";
 import { usageExport as makeUsageExport } from "./products/observability.js";
-import { Sandbox, deleteSandbox, sandboxPage } from "./sandbox.js";
+import { Machines } from "./machine.js";
+import { SANDBOXES, Sandbox } from "./sandbox.js";
 import { Snapshots } from "./snapshots.js";
 import { DEFAULT_BASE_URL, Transport, missingKey } from "./transport.js";
 /** The key `runtime login` saved for this machine and this API origin, found
@@ -43,6 +42,7 @@ export class Runtime {
             ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
             ...(options.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),
             ...(options.maxConnections !== undefined ? { maxConnections: options.maxConnections } : {}),
+            ...(options.onQueued ? { onQueued: options.onQueued } : {}),
             ...(options.waitForCapacityMs !== undefined
                 ? { waitForCapacityMs: options.waitForCapacityMs }
                 : {}),
@@ -68,8 +68,8 @@ export class Runtime {
             ...options,
         });
     }
-    /** Balance, holds, trial time and per-resource charges, in integer microdollars. */
-    /** Credit, holds, trial time and per-resource charges. */
+    /** Balance, holds, free time and per-resource charges, in integer microdollars. */
+    /** Credit, holds, free time and per-resource charges. */
     usage(options = {}) {
         return this.transport.json({
             method: "GET",
@@ -89,115 +89,10 @@ export class Runtime {
         });
     }
 }
-export class Sandboxes {
-    t;
+/** `runtime.sandboxes`: the sandbox product of the machine engine. */
+export class Sandboxes extends Machines {
     constructor(t) {
-        this.t = t;
-    }
-    /** Creates a sandbox and waits until it is running. Every field is optional:
-     * with none you get the free trial while it lasts, the default region and a
-     * 2 vCPU / 4 GiB machine from a warm template. `wait: false` returns at once.
-     * When every trial slot or the account's quota is taken, it waits for one to
-     * free, up to `waitForCapacityMs` (the client's, two minutes by default). */
-    async create(input = {}, options = {}) {
-        const { wait, ...body } = input;
-        const began = performance.now();
-        // Time spent waiting for capacity is the room's, not the deadline's.
-        let waited = 0;
-        const info = await this.t.json({
-            method: "POST",
-            path: "/v1/sandboxes",
-            body,
-            wait: wait === false ? 0 : 60,
-            ...options,
-            waitForCapacityMs: options.waitForCapacityMs ?? this.t.waitForCapacityMs,
-            onCapacityWait: (refusal, waitMs) => {
-                waited += waitMs;
-                options.onCapacityWait?.(refusal, waitMs);
-            },
-        });
-        const sandbox = new Sandbox(this.t, info);
-        if (wait !== false && info.state !== "running") {
-            // One deadline for the whole create: the wait for running gets what the
-            // create left of it (1 ms when nothing is left, so it ends as a timeout).
-            const { timeoutMs } = options;
-            await sandbox.waitFor("running", {
-                timeoutSeconds: WAIT_FOR_TIMEOUT_SECONDS,
-                signal: options.signal,
-                timeoutMs: timeoutMs
-                    ? Math.max(1, Math.ceil(timeoutMs - (performance.now() - began - waited)))
-                    : timeoutMs,
-                idempotencyKey: options.idempotencyKey,
-            });
-            if (sandbox.state !== "running")
-                throw new RuntimeError({
-                    message: `Sandbox ${info.id} is ${sandbox.state}, not running.`,
-                    code: "start_failed",
-                    status: 0,
-                    hint: "Read it with runtime.sandboxes.get(id); stopReason says why.",
-                });
-        }
-        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. */
-    async getOrCreate(name, input = {}, options = {}) {
-        return this.create({ ...input, name, getOrCreate: true }, options);
-    }
-    async get(id, options = {}) {
-        return new Sandbox(this.t, await this.t.json({
-            method: "GET",
-            path: `/v1/sandboxes/${encodeURIComponent(id)}`,
-            ...options,
-        }));
-    }
-    /** Deletes a sandbox for good, by id, without reading it first: see
-     * `sandbox.delete()`. Deleting it again answers the same. */
-    delete(id, options = {}) {
-        return deleteSandbox(this.t, id, options);
-    }
-    /** Live sandboxes, oldest first. Await for a page, or `for await` over all.
-     * Request options apply to the initial request and every subsequent page. */
-    async list(filter = {}, options = {}) {
-        const query = {
-            ...(filter.state ? { state: filter.state } : {}),
-            ...(filter.includeStopped ? { includeStopped: true } : {}),
-            ...(filter.labels
-                ? { label: Object.entries(filter.labels).map(([k, v]) => `${k}:${v}`) }
-                : {}),
-            ...(filter.name ? { name: filter.name } : {}),
-            ...(filter.limit ? { limit: filter.limit } : {}),
-        };
-        return sandboxPage(this.t, await this.t.json({ method: "GET", path: "/v1/sandboxes", query, ...options }), query, options);
-    }
-    /** Stops every live sandbox whose labels all match, eight at a time, and
-     * says which stopped and which failed; one failure does not stop the rest.
-     * Needs at least one label, so stopping everything is never one call. */
-    async stopAll(filter, options = {}) {
-        if (!filter?.labels || Object.keys(filter.labels).length === 0)
-            throw new RuntimeError({
-                message: "stopAll needs at least one label to match.",
-                code: "invalid_request",
-                status: 0,
-                hint: "Stop one sandbox with sandbox.stop(), or label the ones to stop together.",
-            });
-        const live = await (await this.list({ labels: filter.labels, limit: 100 }, options)).toArray(Infinity);
-        // One key cannot name several stops: each stop makes its own.
-        const { idempotencyKey: _one, ...each } = options;
-        // In list order, oldest first, whichever finishes first.
-        const errors = new Array(live.length);
-        let next = 0;
-        const worker = async () => {
-            for (let at = next++; at < live.length; at = next++)
-                await live[at].stop(each).catch((error) => (errors[at] = error ?? "failed"));
-        };
-        await Promise.all(Array.from({ length: Math.min(8, live.length) }, worker));
-        return {
-            stopped: live.filter((_, at) => errors[at] === undefined).map((sbx) => sbx.id),
-            failed: live.flatMap((sbx, at) => errors[at] === undefined ? [] : [{ id: sbx.id, error: errors[at] }]),
-        };
+        super(SANDBOXES, t, (transport, info) => new Sandbox(transport, info));
     }
 }
 export class FeedbackApi {

package/dist/daytona/daytona.d.ts

@@ -177,8 +177,7 @@ export declare class Daytona implements AsyncDisposable {
     [Symbol.asyncDispose](): Promise<void>;
     /** Creates a sandbox and waits until it runs, with Daytona's defaults: 1
      * vCPU, 1 GiB, 3 GiB disk, pausing after 15 minutes without calls. Funding
-     * is left to Runtime: the free trial while the account has trial time, then
-     * prepaid credit, exactly as withruntime's own create. */
+     * is left to Runtime: the included usage first, then prepaid credit, exactly as withruntime's own create. */
     create(params?: CreateSandboxFromSnapshotParams | CreateSandboxFromImageParams, options?: {
         timeout?: number;
         onSnapshotCreateLogs?: (chunk: string) => void;

package/dist/daytona/daytona.js

@@ -183,8 +183,7 @@ export class Daytona {
     async [Symbol.asyncDispose]() { }
     /** Creates a sandbox and waits until it runs, with Daytona's defaults: 1
      * vCPU, 1 GiB, 3 GiB disk, pausing after 15 minutes without calls. Funding
-     * is left to Runtime: the free trial while the account has trial time, then
-     * prepaid credit, exactly as withruntime's own create. */
+     * is left to Runtime: the included usage first, then prepaid credit, exactly as withruntime's own create. */
     async create(params = {}, options = {}) {
         refuseCreate(params);
         const client = params.withruntime?.client ?? this.#client;

package/dist/daytona/sandbox.d.ts

@@ -125,7 +125,7 @@ export declare class Sandbox {
     /** Pauses the sandbox with its memory. */
     pause(_timeout?: number): Promise<void>;
     /** Runtime has no archive tier: a stopped sandbox stays paused, kept for
-     * its retention (30 days paid, 7 on the trial, or autoDeleteInterval). */
+     * its retention (30 days paid, 7 without credit, or autoDeleteInterval). */
     archive(): Promise<void>;
     /** Ends the sandbox for good. */
     delete(_timeout?: number): Promise<void>;

package/dist/daytona/sandbox.js

@@ -269,7 +269,7 @@ export class Sandbox {
         this.#pausedByPause = true;
     }
     /** Runtime has no archive tier: a stopped sandbox stays paused, kept for
-     * its retention (30 days paid, 7 on the trial, or autoDeleteInterval). */
+     * its retention (30 days paid, 7 without credit, or autoDeleteInterval). */
     async archive() {
         await this.stop();
     }

package/dist/e2b/client.d.ts

@@ -43,15 +43,28 @@ export interface RuntimeOpts {
 /** Refuses the E2B-only connection options: they point at E2B, and quietly
  * dropping one would send the call somewhere its author did not mean. */
 export declare function refuseE2BConnection(opts?: ConnectionOpts): void;
+/** Connections the adapter's own client may hold at once: E2B's SDK has no
+ * cap of its own, so an orchestrator that drives a thousand sandboxes from one
+ * process runs every command at once. 4,096 is the widest room Runtime's edge
+ * gives an address that has used a valid key (api.md, "Limits"); the edge and
+ * the API answer anything past an account's room with a retry, which the
+ * client waits out. Runtime's own SDK keeps 48. */
+export declare const E2B_MAX_CONNECTIONS = 4096;
+/** Said once per process, the first time a call has to wait for a
+ * connection: E2B never holds a call back, so a caller should hear it. */
+export declare function warnQueued(maxConnections: number): void;
 /** The Runtime client for these options: an explicit client, else one per key,
  * made once and reused so its connections stay open. */
 export declare function clientFor(opts?: ConnectionOpts & {
     runtime?: RuntimeOpts;
 }): Runtime;
 /** Explicit key, then RUNTIME_API_KEY, then E2B_API_KEY when it holds a
- * Runtime key; undefined lets the Runtime SDK find the saved login. */
+ * Runtime key; undefined, when none is set, lets the Runtime SDK find the
+ * saved login. An E2B key is refused, never sent. */
 export declare function pickKey(explicit?: string): string | undefined;
-/** Test hook: forget the cached clients. */
+/** Where the key in use came from, as an error names it. */
+export declare function keySource(explicit?: string): string;
+/** Test hook: forget the cached clients and the warnings. */
 export declare function resetClients(): void;
 /** Request options for a Runtime call from E2B's. */
 export declare function request(opts?: {

package/dist/e2b/client.js

@@ -26,6 +26,23 @@ export function refuseE2BConnection(opts = {}) {
         throw new NotSupportedError("E2B's debug mode (a local envd)", "Remove debug: true; there is no local Runtime guest to connect to.");
 }
 const clients = new Map();
+/** Connections the adapter's own client may hold at once: E2B's SDK has no
+ * cap of its own, so an orchestrator that drives a thousand sandboxes from one
+ * process runs every command at once. 4,096 is the widest room Runtime's edge
+ * gives an address that has used a valid key (api.md, "Limits"); the edge and
+ * the API answer anything past an account's room with a retry, which the
+ * client waits out. Runtime's own SDK keeps 48. */
+export const E2B_MAX_CONNECTIONS = 4096;
+let warnedQueued = false;
+/** Said once per process, the first time a call has to wait for a
+ * connection: E2B never holds a call back, so a caller should hear it. */
+export function warnQueued(maxConnections) {
+    if (warnedQueued || typeof process === "undefined" || !process.emitWarning)
+        return;
+    warnedQueued = true;
+    process.emitWarning(`More than ${maxConnections} calls and command streams are open at once from this process, so the rest wait their turn. ` +
+        "Pass runtime: { client: new Runtime({ maxConnections }) } for more.", { code: "RUNTIME_E2B_QUEUED" });
+}
 /** The Runtime client for these options: an explicit client, else one per key,
  * made once and reused so its connections stay open. */
 export function clientFor(opts = {}) {
@@ -36,30 +53,67 @@ export function clientFor(opts = {}) {
     const cacheKey = key ?? "";
     let client = clients.get(cacheKey);
     if (!client) {
-        client = new Runtime(key ? { apiKey: key } : {});
+        client = new Runtime({
+            ...(key ? { apiKey: key } : {}),
+            maxConnections: E2B_MAX_CONNECTIONS,
+            onQueued: warnQueued,
+        });
         clients.set(cacheKey, client);
     }
     return client;
 }
 /** Explicit key, then RUNTIME_API_KEY, then E2B_API_KEY when it holds a
- * Runtime key; undefined lets the Runtime SDK find the saved login. */
+ * Runtime key; undefined, when none is set, lets the Runtime SDK find the
+ * saved login. An E2B key is refused, never sent. */
 export function pickKey(explicit) {
     const runtimeKey = env("RUNTIME_API_KEY");
     if (explicit !== undefined && !isE2BKey(explicit))
         return explicit;
-    if (runtimeKey)
+    if (runtimeKey) {
+        warnTwoKeys(runtimeKey, env("E2B_API_KEY"));
         return runtimeKey;
+    }
     if (explicit !== undefined)
         throw new AuthenticationError("The apiKey passed is an E2B API key (e2b_...), and it was not sent. Set RUNTIME_API_KEY to a Runtime key " +
             "(https://withruntime.com/account/keys, or run `npx withruntime login`), or pass the Runtime key as apiKey.");
-    // An E2B key left in E2B_API_KEY is skipped, never sent: the Runtime SDK
-    // then uses the key `npx withruntime login` saved, or says none was found.
+    // An E2B key left in E2B_API_KEY is never sent, and never quietly passed
+    // over for the key `npx withruntime login` saved, which may be another
+    // account's.
     const e2bVariable = env("E2B_API_KEY");
-    return e2bVariable && !isE2BKey(e2bVariable) ? e2bVariable : undefined;
+    if (e2bVariable && isE2BKey(e2bVariable))
+        throw new AuthenticationError("E2B_API_KEY holds an E2B API key (e2b_...), and it was not sent. Set RUNTIME_API_KEY to a Runtime key " +
+            "(https://withruntime.com/account/keys, or run `npx withruntime login`), or put the Runtime key in E2B_API_KEY.");
+    return e2bVariable || undefined;
+}
+/** Where the key in use came from, as an error names it. */
+export function keySource(explicit) {
+    if (explicit !== undefined && !isE2BKey(explicit))
+        return "apiKey";
+    if (env("RUNTIME_API_KEY"))
+        return "RUNTIME_API_KEY";
+    if (env("E2B_API_KEY"))
+        return "E2B_API_KEY";
+    return "the saved login";
+}
+let warnedTwoKeys = false;
+/** Said once per process: RUNTIME_API_KEY wins, as in Runtime's own SDK, but
+ * code written for E2B means E2B_API_KEY, so two different Runtime keys are
+ * likely two accounts, and the wrong one fails later as a missing image
+ * (5 October 2026). */
+function warnTwoKeys(runtimeKey, e2bVariable) {
+    if (!e2bVariable || isE2BKey(e2bVariable) || e2bVariable === runtimeKey)
+        return;
+    if (warnedTwoKeys || typeof process === "undefined" || !process.emitWarning)
+        return;
+    warnedTwoKeys = true;
+    process.emitWarning("RUNTIME_API_KEY and E2B_API_KEY hold different Runtime keys, which may be different accounts; this package uses " +
+        "RUNTIME_API_KEY. Unset one, or set both to the same key.", { code: "RUNTIME_E2B_TWO_KEYS" });
 }
-/** Test hook: forget the cached clients. */
+/** Test hook: forget the cached clients and the warnings. */
 export function resetClients() {
     clients.clear();
+    warnedQueued = false;
+    warnedTwoKeys = false;
 }
 /** Request options for a Runtime call from E2B's. */
 export function request(opts = {}) {

package/dist/e2b/commands.d.ts

@@ -43,6 +43,9 @@ export interface SandboxContext {
     /** Makes /home/user (E2B's home) lead to /workspace (Runtime's), once, when
      * something names it. */
     ensureHome(text: string | undefined, options?: RequestOptions): Promise<void>;
+    /** Whether /home/user leads to /workspace, linking it first if nothing is
+     * there; false when that cannot be told. Never fails. */
+    homeIsWorkspace(): Promise<boolean>;
 }
 /** E2B's pids are numbers; Runtime's process ids are strings. The number is a
  * 31-bit FNV-1a hash of the id, so every client derives the same one. */

package/dist/e2b/commands.js

@@ -1,5 +1,5 @@
-import { CommandExitError, guard, InvalidArgumentError, SandboxError, TimeoutError, translate, } from "./errors.js";
-import { commandAs, runAs } from "./users.js";
+import { CommandExitError, guard, InvalidArgumentError, SandboxError, SandboxNotFoundError, TimeoutError, translate, } from "./errors.js";
+import { commandAs, listedAs, runAs } from "./users.js";
 const DEFAULT_TIMEOUT_MS = 60_000;
 /** How long a command may run on Runtime: a day, E2B's longest sandbox. E2B's
  * own `timeoutMs` bounds only the connection, so the process gets this. */
@@ -238,12 +238,19 @@ export class Commands {
 function describe(info) {
     return {
         pid: pidOf(info.id),
-        cmd: "/bin/bash",
-        args: ["-c", info.command],
+        ...listedAs(info.command),
         envs: {},
         cwd: info.cwd,
     };
 }
+/** A command whose sandbox went away under it, as E2B says it: a
+ * TimeoutError, which code written for E2B catches (5 October 2026: it was a
+ * SandboxNotFoundError). */
+function sandboxEnded(cause) {
+    const error = new TimeoutError("The command ended before the stream completed: the sandbox was killed or reached its end of life.");
+    error.cause = cause;
+    return error;
+}
 /** Reader cancellation also releases a callback whose promise never settles. */
 async function deliver(signal, callback) {
     signal.throwIfAborted();
@@ -349,7 +356,11 @@ export class CommandHandle {
             if (!this.#disconnected && !this.#failure) {
                 const translated = translate(error, "sandbox");
                 this.#failure =
-                    translated instanceof Error ? translated : new SandboxError(String(translated));
+                    translated instanceof SandboxNotFoundError
+                        ? sandboxEnded(translated)
+                        : translated instanceof Error
+                            ? translated
+                            : new SandboxError(String(translated));
             }
         }
         finally {

package/dist/e2b/errors.d.ts

@@ -37,6 +37,31 @@ export declare class ServiceBusyError extends Error {
     requestId?: string;
     constructor(message: string);
 }
+/** E2B's other error classes, by the same names and parents, so a module
+ * that imports or catches them loads and works: nothing in this package
+ * throws them, since the features behind them (template builds, git,
+ * volumes, secrets) answer NotSupportedError here. */
+export declare class GitAuthError extends AuthenticationError {
+}
+export declare class GitUpstreamError extends SandboxError {
+}
+export declare class BuildError extends Error {
+    constructor(message?: string);
+}
+export declare class FileUploadError extends BuildError {
+}
+export declare class VolumeError extends Error {
+    constructor(message?: string);
+}
+export declare class VolumeNotFoundError extends VolumeError {
+}
+export declare class VolumePathNotFoundError extends VolumeError {
+}
+export declare class SecretError extends Error {
+    constructor(message?: string);
+}
+export declare class SecretNotFoundError extends SecretError {
+}
 /** A call that E2B supports and Runtime does not, or not in the same way.
  * Thrown before anything is done, never after doing something different.
  * `feature` names what was asked for; `alternative` says what to use on
@@ -46,8 +71,7 @@ export declare class NotSupportedError extends SandboxError {
     readonly alternative: string;
     constructor(feature: string, alternative: string, message?: string);
 }
-/** Runtime's addition, for `getHost` and `getPublicHost`: a free-trial
- * sandbox shares a port only privately, so a request needs the port's token,
+/** Runtime's addition, for `getHost` and `getPublicHost`: a sandbox without credit shares a port only privately, so a request needs the port's token,
  * and a host name alone cannot carry one. The message says what works. A
  * NotSupportedError, so code that catches those catches this too. */
 export declare class PublicPreviewNotAllowedError extends NotSupportedError {

package/dist/e2b/errors.js

@@ -58,6 +58,40 @@ export class ServiceBusyError extends Error {
         this.name = new.target.name;
     }
 }
+/** E2B's other error classes, by the same names and parents, so a module
+ * that imports or catches them loads and works: nothing in this package
+ * throws them, since the features behind them (template builds, git,
+ * volumes, secrets) answer NotSupportedError here. */
+export class GitAuthError extends AuthenticationError {
+}
+export class GitUpstreamError extends SandboxError {
+}
+export class BuildError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+export class FileUploadError extends BuildError {
+}
+export class VolumeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+export class VolumeNotFoundError extends VolumeError {
+}
+export class VolumePathNotFoundError extends VolumeError {
+}
+export class SecretError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+export class SecretNotFoundError extends SecretError {
+}
 /** A call that E2B supports and Runtime does not, or not in the same way.
  * Thrown before anything is done, never after doing something different.
  * `feature` names what was asked for; `alternative` says what to use on
@@ -72,19 +106,18 @@ export class NotSupportedError extends SandboxError {
         this.code = "not_supported";
     }
 }
-/** Runtime's addition, for `getHost` and `getPublicHost`: a free-trial
- * sandbox shares a port only privately, so a request needs the port's token,
+/** Runtime's addition, for `getHost` and `getPublicHost`: a sandbox without credit shares a port only privately, so a request needs the port's token,
  * and a host name alone cannot carry one. The message says what works. A
  * NotSupportedError, so code that catches those catches this too. */
 export class PublicPreviewNotAllowedError extends NotSupportedError {
     constructor(sandboxId, port, message) {
         const where = port === undefined ? "<port>" : String(port);
-        const alternative = `For an address that works on the trial, use (await sandbox.runtime.previews.create(${where})).urlWithToken: ` +
+        const alternative = `For an address that works without credit, use (await sandbox.runtime.previews.create(${where})).urlWithToken: ` +
             "it carries the token, in a browser, fetch or curl. For other paths on it, send the token as the " +
             "x-runtime-preview-token header or the runtime_preview_token query parameter. A public host needs a paid " +
             "sandbox, which is the account owner's decision.";
-        super("A public address on a free-trial sandbox", alternative, message ??
-            `Sandbox ${sandboxId} runs on the free trial, where a shared port is private: every request needs the ` +
+        super("A public address on a sandbox without credit", alternative, message ??
+            `Sandbox ${sandboxId} runs without credit, where a shared port is private: every request needs the ` +
                 `port's token, and a host name alone cannot carry one. ${alternative}`);
         this.code = "public_preview_not_allowed";
     }

package/dist/e2b/filesystem.d.ts

@@ -72,7 +72,7 @@ export interface FilesystemListOpts extends FilesystemRequestOpts {
 }
 /** `sandbox.files`: E2B's filesystem module over Runtime's files API. Relative
  * paths resolve against the home directory, as in E2B (Runtime's is
- * /workspace). */
+ * /workspace), and come back under /home/user, as E2B gives them. */
 export declare class Filesystem {
     #private;
     constructor(ctx: SandboxContext);