@lizard-build/sdk 0.1.40 → 0.1.42

package/dist/index.d.ts

@@ -114,7 +114,7 @@ declare class AddonsAPI {
         memoryMb?: number;
         storageGb?: number;
     }): Promise<Addon>;
-    /** Restart an addon VM. */
+    /** Restart an addon. */
     redeploy(projectId: string, addonId: string): Promise<void>;
     rename(projectId: string, addonId: string, name: string): Promise<unknown>;
     secrets(projectId: string, addonId: string): Promise<Array<{
@@ -395,7 +395,7 @@ interface ProcessInfo {
 /** Signals accepted by {@link Process.kill}. */
 type ProcessSignal = 'SIGTERM' | 'SIGKILL' | 'SIGINT' | 'SIGHUP' | 'SIGQUIT' | 'SIGUSR1' | 'SIGUSR2';
 /**
- * The result of a process execution inside a Lizard microVM.
+ * The result of a process execution inside a Lizard sandbox.
  */
 interface ProcessResult {
     stdout: string;
@@ -418,7 +418,7 @@ interface ProcessOpts {
     onPid?: (pid: number) => void;
 }
 /**
- * Runs processes inside a Lizard sandbox microVM.
+ * Runs processes inside a Lizard sandbox.
  *
  * Access via `sandbox.process`.
  */
@@ -427,12 +427,12 @@ declare class Process {
     private readonly config;
     constructor(sandboxId: string, config: ConnectionConfig);
     /**
-     * Execute a command inside the microVM and wait for it to complete.
+     * Execute a command inside the sandbox and wait for it to complete.
      *
      * The command runs in a shell inside the Lizard sandbox and returns
      * stdout, stderr, and the exit code when it finishes.
      *
-     * @param cmd Shell command to run inside the microVM.
+     * @param cmd Shell command to run inside the sandbox.
      * @param opts Optional execution options — environment variables, working
      *   directory, user, and timeout.
      *
@@ -511,7 +511,7 @@ interface FileInfo {
     modTime?: number;
 }
 /**
- * Read and write files inside a Lizard sandbox microVM.
+ * Read and write files inside a Lizard sandbox.
  *
  * Access via `sandbox.fs`.
  */
@@ -520,23 +520,24 @@ declare class Fs {
     private readonly config;
     constructor(sandboxId: string, config: ConnectionConfig);
     /**
-     * Write a file into the microVM filesystem.
+     * Write a file into the sandbox filesystem.
      *
      * Creates parent directories automatically if they don't exist.
+     * Byte input must contain valid UTF-8; arbitrary binary uploads are unsupported.
      *
      * @example
      * ```ts
      * await sandbox.fs.write('/app/index.js', 'console.log("hello")')
      * ```
      *
-     * @example Write binary data:
+     * @example Write UTF-8 bytes:
      * ```ts
-     * await sandbox.fs.write('/app/data.bin', buffer)
+     * await sandbox.fs.write('/app/notes.txt', new TextEncoder().encode('hello'))
      * ```
      */
     write(path: string, data: string | Uint8Array, opts?: FsOpts): Promise<void>;
     /**
-     * Read a file from the microVM filesystem.
+     * Read a file from the sandbox filesystem.
      *
      * @returns The file contents as a UTF-8 string.
      *
@@ -546,22 +547,23 @@ declare class Fs {
      * ```
      */
     read(path: string, opts?: FsOpts): Promise<string>;
+    /** Read a file as bytes. */
+    readBytes(path: string, opts?: FsOpts): Promise<Uint8Array>;
     /**
-     * List files and directories at the given path inside the microVM.
+     * List files and directories at the given path inside the sandbox.
      *
      * @example
      * ```ts
      * const entries = await sandbox.fs.list('/app')
      * ```
      */
-    readBytes(path: string, opts?: FsOpts): Promise<Uint8Array>;
     list(path: string, opts?: FsOpts): Promise<FileInfo[]>;
     /**
-     * Remove a file or directory from the microVM filesystem.
+     * Remove a file or directory from the sandbox filesystem.
      */
     remove(path: string, opts?: FsOpts): Promise<void>;
     /**
-     * Create a directory (and any missing parents) inside the microVM.
+     * Create a directory (and any missing parents) inside the sandbox.
      */
     makeDir(path: string, opts?: FsOpts): Promise<void>;
     /**
@@ -730,10 +732,9 @@ declare class SandboxClient {
 }
 
 /**
- * A Lizard sandbox — an isolated Linux environment that starts in under a second.
+ * A Linux sandbox running on Kubernetes.
  *
- * Each sandbox is a full Linux environment with its own filesystem, network, and
- * process namespace, restored from a pre-warmed template snapshot.
+ * Run commands, read and write files, and expose HTTP ports in a sandbox.
  *
  * Sandboxes are **ephemeral**: killing one, or letting it hit its timeout, discards
  * everything written inside it. State that has to outlive a sandbox belongs on a
@@ -745,10 +746,14 @@ declare class SandboxClient {
  * import { Sandbox } from '@lizard-build/sdk'
  *
  * const sandbox = await Sandbox.create('base', { project: 'my-project' })
- * await sandbox.fs.write('/app/index.js', 'console.log("hello world")')
- * const result = await sandbox.process.exec('node /app/index.js')
- * console.log(result.stdout) // "hello world"
- * await sandbox.kill()
+ * try {
+ *   await sandbox.fs.write('/tmp/hello.txt', 'hello world')
+ *   const result = await sandbox.process.exec('cat /tmp/hello.txt')
+ *   if (result.exitCode !== 0) throw new Error(result.stderr)
+ *   console.log(result.stdout)
+ * } finally {
+ *   await sandbox.kill()
+ * }
  * ```
  *
  * @example Carry work across sandboxes with a volume:
@@ -769,11 +774,11 @@ declare class Sandbox extends SandboxClient {
     protected static readonly defaultTemplate: string;
     protected static readonly defaultTimeoutMs: number;
     /**
-     * Unique identifier of this sandbox microVM.
+     * Unique identifier of this sandbox.
      */
     readonly sandboxId: string;
     /**
-     * Read and write files inside the microVM filesystem.
+     * Read and write files inside the sandbox filesystem.
      *
      * @example
      * ```ts
@@ -783,7 +788,7 @@ declare class Sandbox extends SandboxClient {
      */
     readonly fs: Fs;
     /**
-     * Execute processes inside the microVM.
+     * Execute processes inside the sandbox.
      *
      * @example
      * ```ts
@@ -807,16 +812,15 @@ declare class Sandbox extends SandboxClient {
     /**
      * Create a new Lizard sandbox from the specified template.
      *
-     * Available templates: `base` (Debian + Node.js 26) and `code-interpreter-v1`
-     * (Python 3.14 + Node.js 26). Custom templates can be built and pushed via
-     * `lizard push`.
+     * Template availability and installed tools depend on the platform and region.
+     * Use `base` for shell commands or `CodeSandbox` for stateful code execution.
      *
      * @param template Name of the sandbox template to boot from.
      *
      * @example
      * ```ts
      * const sandbox = await Sandbox.create('base', { project: 'my-project' })
-     * const sandbox = await Sandbox.create('code-interpreter-v1', { project: 'my-project', timeoutMs: 10 * 60 * 1000 })
+     * const pythonSandbox = await Sandbox.create('code-interpreter-v1', { project: 'my-project', timeoutMs: 10 * 60 * 1000 })
      * ```
      */
     static create(template: string, opts?: SandboxOpts): Promise<Sandbox>;
@@ -826,11 +830,7 @@ declare class Sandbox extends SandboxClient {
      * Verifies the sandbox exists and is reachable, then returns a handle to it.
      * Throws `NotFoundError` if it has been killed or has expired.
      *
-     * This used to call `resume` first, on the assumption that a sandbox you are
-     * reconnecting to might be paused. Sandboxes are pods now and pause/resume is a
-     * `501` on every one of them, so that call turned every `connect()` into an
-     * error against a perfectly healthy sandbox. Connecting does not need to change
-     * a sandbox's state, so it no longer tries to.
+     * Connecting reads sandbox metadata without changing its state.
      *
      * @example
      * ```ts
@@ -852,25 +852,21 @@ declare class Sandbox extends SandboxClient {
     /**
      * Kill the sandbox and release its resources immediately.
      *
-     * @returns `true` if the microVM was terminated, `false` if it was already gone.
+     * @returns `true` if the sandbox was terminated, `false` if it was already gone.
      */
     kill(opts?: ConnectionOpts): Promise<boolean>;
     /**
-     * Pause the sandbox by freezing it in place.
+     * Request sandbox pause. The Kubernetes backend returns HTTP 501.
      *
-     * @deprecated Not implemented for the current runtime — always throws
-     * `LizardError` with HTTP 501. Sandboxes run as pods, and the equivalent is a CRIU
-     * checkpoint of the pod, which is not built. To park work across a gap, put it on a
-     * {@link Volume} and create a fresh sandbox on that volume later; the volume is the
-     * part that is meant to outlive a sandbox.
+     * @deprecated Unsupported on Kubernetes. Save files to a {@link Volume}
+     * and attach it to a new sandbox instead.
      */
     pause(opts?: ConnectionOpts): Promise<boolean>;
     /**
-     * Resume a paused sandbox.
+     * Request sandbox resume. The Kubernetes backend returns HTTP 501.
      *
-     * @deprecated Not implemented for the current runtime — always throws
-     * `LizardError` with HTTP 501. See {@link pause}. `Sandbox.connect()` no longer
-     * calls this, so reconnecting to a running sandbox works without it.
+     * @deprecated Unsupported on Kubernetes. Use {@link Sandbox.connect} to
+     * reconnect to a running sandbox.
      */
     resume(opts?: ConnectionOpts): Promise<boolean>;
     /**
@@ -884,23 +880,25 @@ declare class Sandbox extends SandboxClient {
      */
     setTimeout(timeoutMs: number, opts?: ConnectionOpts): Promise<void>;
     /**
-     * Get the public HTTPS URL for a port exposed inside the sandbox.
+     * Register a public HTTPS route and return its hostname without a scheme.
      *
-     * Useful for accessing HTTP servers started inside the microVM from your
+     * Useful for accessing HTTP servers started inside the sandbox from your
      * agent or tests without additional tunneling.
      *
      * @example
      * ```ts
-     * await sandbox.process.exec('npx -y serve -p 3000 &')
-     * const url = sandbox.getHost(3000)
-     * // https://{sandboxId}-3000.sandbox.{region}.onlizard.com
+     * // Start an HTTP server on port 3000 before exposing it.
+     * const hostname = await sandbox.getHost(3000)
+     * console.log(`https://${hostname}`)
      * ```
      */
     getHost(port: number, opts?: ConnectionOpts): Promise<string>;
+    /** Fork is unsupported on Kubernetes; the backend returns HTTP 501. */
     fork(opts?: {
         count?: number;
         timeoutMs?: number;
     }): Promise<unknown>;
+    /** Snapshot creation is unsupported on Kubernetes; the backend returns HTTP 501. */
     snapshot(name?: string): Promise<unknown>;
     unexpose(port: number): Promise<void>;
     logs(opts?: {
@@ -908,6 +906,7 @@ declare class Sandbox extends SandboxClient {
         signal?: AbortSignal;
     }): AsyncGenerator<StreamEvent, any, any>;
     static snapshots(projectId: string, opts?: ConnectionOpts): Promise<unknown[]>;
+    /** Snapshot restore is unsupported on Kubernetes; the backend returns HTTP 501. */
     static restore(snapshotId: string, opts?: ConnectionOpts & {
         timeoutMs?: number;
     }): Promise<Sandbox>;
@@ -1353,6 +1352,12 @@ interface VolumeInfo {
     status: string;
     attachedTo?: string | null;
     createdAt: number;
+    /**
+     * Whether `sizeGb` is actually enforced as a hard limit on the volume's node.
+     * Returned by {@link Volume.resize}; `false` means the size was recorded but the
+     * node cannot enforce it, so writes past it are not refused.
+     */
+    sizeEnforced?: boolean;
 }
 interface CreateVolumeOpts extends ConnectionOpts {
     /** Whole GB, default 5. New volumes allow 1–50 GB unless the server config sets another maximum. Existing volumes are never resized. */
@@ -1400,8 +1405,8 @@ declare class Volume {
      * exist yet. This is the reason a volume's name is its key: an agent that wants
      * "the scratch disk for this task" no longer has to store an id between runs.
      *
-     * An existing volume is returned as-is — `sizeGb` applies only to a fresh create
-     * and never resizes one that is already there.
+     * An existing volume is returned as-is — `sizeGb` applies only to a fresh create,
+     * so an existing volume keeps its size. Call {@link Volume.resize} to change it.
      */
     static getOrCreate(projectId: string, name: string, opts?: CreateVolumeOpts): Promise<Volume>;
     /** Look a volume up by name or by id. */
@@ -1409,7 +1414,26 @@ declare class Volume {
     static list(projectId: string, opts?: ConnectionOpts): Promise<VolumeInfo[]>;
     /** Delete a volume by name or by id, without constructing one first. */
     static delete(projectId: string, nameOrId: string, opts?: ConnectionOpts): Promise<void>;
+    /**
+     * Resize a volume, by name or by id, to `sizeGb`.
+     *
+     * The change is in place and online: the size is a quota, so no data is copied,
+     * it completes in well under a second, and a sandbox that has the volume mounted
+     * keeps running and sees the new size immediately. Both growing and shrinking are
+     * allowed, but a shrink must leave at least 10% of the new size free — otherwise
+     * it throws `ConflictError` with `code: 'volume_too_full_to_shrink'`.
+     *
+     * Other failures carry a `code` too: `invalid_volume_size`, `volume_not_resizable`,
+     * `volume_resize_in_progress`, `volume_not_provisioned`,
+     * `volume_capacity_unavailable`, and `volume_resize_timeout` (a `TimeoutError`;
+     * the size is left unchanged).
+     *
+     * @returns The volume's updated info, including `sizeEnforced`.
+     */
+    static resize(projectId: string, nameOrId: string, sizeGb: number, opts?: ConnectionOpts): Promise<VolumeInfo>;
     getInfo(projectId: string): Promise<VolumeInfo>;
+    /** Resize this volume in place — see the static {@link Volume.resize}. */
+    resize(projectId: string, sizeGb: number): Promise<VolumeInfo>;
     delete(projectId: string): Promise<void>;
 }
 
@@ -1509,6 +1533,7 @@ declare class Lizard {
         getOrCreate: (name: string, opts?: CreateVolumeOpts) => Promise<Volume>;
         get: (nameOrId: string, opts?: ConnectionOpts) => Promise<Volume>;
         list: (opts?: ConnectionOpts) => Promise<VolumeInfo[]>;
+        resize: (nameOrId: string, sizeGb: number, opts?: ConnectionOpts) => Promise<VolumeInfo>;
         delete: (nameOrId: string, opts?: ConnectionOpts) => Promise<void>;
     };
     /**
@@ -1558,6 +1583,13 @@ interface Account {
 declare function resolveProjectId(ref: string, config: ConnectionConfig): Promise<string>;
 
 declare class LizardError extends Error {
+    /** HTTP status of the failed API call, when the error came from one. */
+    status?: number;
+    /**
+     * The server's machine-readable error code, when it sent one — e.g.
+     * `'volume_too_full_to_shrink'`. Branch on this rather than on `message`.
+     */
+    code?: string;
     constructor(message: string);
 }
 /** Config was saved, but one or more deploy/restart actions failed. Never retry blindly. */
@@ -1602,7 +1634,7 @@ type OutputItem = {
     message: string;
     traceback: string;
 };
-/** Error thrown when executed code raises an exception. */
+/** Error returned in Execution.error when executed code raises an exception. */
 declare class ExecutionError extends Error {
     readonly name: string;
     readonly traceback: string;
@@ -1637,7 +1669,7 @@ interface RunCodeOpts {
     context?: CodeContext;
     /** Extra environment variables available to the code. */
     envs?: Record<string, string>;
-    /** Max time to wait for the code to finish, in ms. Default: 60_000. */
+    /** Client timeout in milliseconds. No client timer is set when omitted. */
     timeoutMs?: number;
     onStdout?: (data: string) => void;
     onStderr?: (data: string) => void;
@@ -1659,7 +1691,7 @@ interface CreateContextOpts {
  *
  * @example
  * ```ts
- * import { CodeSandbox } from 'lizard/code-interpreter'
+ * import { CodeSandbox } from '@lizard-build/sdk'
  *
  * const sandbox = await CodeSandbox.create({ project: 'my-project' })
  *
@@ -1690,8 +1722,7 @@ declare class CodeSandbox extends Sandbox {
      *
      * @returns Execution result with stdout, stderr, results, and any error.
      *
-     * @throws {ExecutionError} if you pass neither language nor context and no
-     *   default context exists — which cannot happen in normal usage.
+     * Code errors appear in `execution.error`; request failures throw.
      *
      * @example
      * ```ts

package/dist/index.js

@@ -112,17 +112,23 @@ var TimeoutError = class extends LizardError {
 };
 async function handleApiError(res) {
   let message;
+  let code;
   try {
     const body = await res.json();
     message = body.error ?? res.statusText;
+    if (typeof body.code === "string") code = body.code;
   } catch {
     message = res.statusText;
   }
-  if (res.status === 401 || res.status === 403) throw new AuthenticationError(message);
-  if (res.status === 404) throw new NotFoundError(message);
-  if (res.status === 409) throw new ConflictError(message);
-  if (res.status === 408 || res.status === 504) throw new TimeoutError(message);
-  throw new LizardError(`API error ${res.status}: ${message}`);
+  let err;
+  if (res.status === 401 || res.status === 403) err = new AuthenticationError(message);
+  else if (res.status === 404) err = new NotFoundError(message);
+  else if (res.status === 409) err = new ConflictError(message);
+  else if (res.status === 408 || res.status === 504) err = new TimeoutError(message);
+  else err = new LizardError(`API error ${res.status}: ${message}`);
+  err.status = res.status;
+  err.code = code;
+  throw err;
 }
 
 // src/platform/client.ts
@@ -501,12 +507,12 @@ var Process = class {
     this.config = config;
   }
   /**
-   * Execute a command inside the microVM and wait for it to complete.
+   * Execute a command inside the sandbox and wait for it to complete.
    *
    * The command runs in a shell inside the Lizard sandbox and returns
    * stdout, stderr, and the exit code when it finishes.
    *
-   * @param cmd Shell command to run inside the microVM.
+   * @param cmd Shell command to run inside the sandbox.
    * @param opts Optional execution options — environment variables, working
    *   directory, user, and timeout.
    *
@@ -638,18 +644,19 @@ var Fs = class {
     this.config = config;
   }
   /**
-   * Write a file into the microVM filesystem.
+   * Write a file into the sandbox filesystem.
    *
    * Creates parent directories automatically if they don't exist.
+   * Byte input must contain valid UTF-8; arbitrary binary uploads are unsupported.
    *
    * @example
    * ```ts
    * await sandbox.fs.write('/app/index.js', 'console.log("hello")')
    * ```
    *
-   * @example Write binary data:
+   * @example Write UTF-8 bytes:
    * ```ts
-   * await sandbox.fs.write('/app/data.bin', buffer)
+   * await sandbox.fs.write('/app/notes.txt', new TextEncoder().encode('hello'))
    * ```
    */
   async write(path, data, opts) {
@@ -662,7 +669,7 @@ var Fs = class {
     if (!res.ok) await handleApiError(res);
   }
   /**
-   * Read a file from the microVM filesystem.
+   * Read a file from the sandbox filesystem.
    *
    * @returns The file contents as a UTF-8 string.
    *
@@ -679,14 +686,7 @@ var Fs = class {
     if (!res.ok) await handleApiError(res);
     return res.text();
   }
-  /**
-   * List files and directories at the given path inside the microVM.
-   *
-   * @example
-   * ```ts
-   * const entries = await sandbox.fs.list('/app')
-   * ```
-   */
+  /** Read a file as bytes. */
   async readBytes(path, opts) {
     const url = new URL(`${this.config.apiUrl}/api/sandboxes/${this.sandboxId}/files`);
     url.searchParams.set("path", path);
@@ -695,6 +695,14 @@ var Fs = class {
     if (!res.ok) await handleApiError(res);
     return new Uint8Array(await res.arrayBuffer());
   }
+  /**
+   * List files and directories at the given path inside the sandbox.
+   *
+   * @example
+   * ```ts
+   * const entries = await sandbox.fs.list('/app')
+   * ```
+   */
   async list(path, opts) {
     const url = new URL(`${this.config.apiUrl}/api/sandboxes/${this.sandboxId}/files/list`);
     url.searchParams.set("path", path);
@@ -704,7 +712,7 @@ var Fs = class {
     return res.json();
   }
   /**
-   * Remove a file or directory from the microVM filesystem.
+   * Remove a file or directory from the sandbox filesystem.
    */
   async remove(path, opts) {
     const res = await fetch(`${this.config.apiUrl}/api/sandboxes/${this.sandboxId}/files`, {
@@ -715,7 +723,7 @@ var Fs = class {
     if (!res.ok) await handleApiError(res);
   }
   /**
-   * Create a directory (and any missing parents) inside the microVM.
+   * Create a directory (and any missing parents) inside the sandbox.
    */
   async makeDir(path, opts) {
     await this.execInternal(`mkdir -p ${JSON.stringify(path)}`, opts?.user);
@@ -943,11 +951,7 @@ var Sandbox = class extends SandboxClient {
    * Verifies the sandbox exists and is reachable, then returns a handle to it.
    * Throws `NotFoundError` if it has been killed or has expired.
    *
-   * This used to call `resume` first, on the assumption that a sandbox you are
-   * reconnecting to might be paused. Sandboxes are pods now and pause/resume is a
-   * `501` on every one of them, so that call turned every `connect()` into an
-   * error against a perfectly healthy sandbox. Connecting does not need to change
-   * a sandbox's state, so it no longer tries to.
+   * Connecting reads sandbox metadata without changing its state.
    *
    * @example
    * ```ts
@@ -972,29 +976,25 @@ var Sandbox = class extends SandboxClient {
   /**
    * Kill the sandbox and release its resources immediately.
    *
-   * @returns `true` if the microVM was terminated, `false` if it was already gone.
+   * @returns `true` if the sandbox was terminated, `false` if it was already gone.
    */
   async kill(opts) {
     return SandboxClient.killSandbox(this.sandboxId, this.resolveOpts(opts));
   }
   /**
-   * Pause the sandbox by freezing it in place.
+   * Request sandbox pause. The Kubernetes backend returns HTTP 501.
    *
-   * @deprecated Not implemented for the current runtime — always throws
-   * `LizardError` with HTTP 501. Sandboxes run as pods, and the equivalent is a CRIU
-   * checkpoint of the pod, which is not built. To park work across a gap, put it on a
-   * {@link Volume} and create a fresh sandbox on that volume later; the volume is the
-   * part that is meant to outlive a sandbox.
+   * @deprecated Unsupported on Kubernetes. Save files to a {@link Volume}
+   * and attach it to a new sandbox instead.
    */
   async pause(opts) {
     return SandboxClient.pauseSandbox(this.sandboxId, this.resolveOpts(opts));
   }
   /**
-   * Resume a paused sandbox.
+   * Request sandbox resume. The Kubernetes backend returns HTTP 501.
    *
-   * @deprecated Not implemented for the current runtime — always throws
-   * `LizardError` with HTTP 501. See {@link pause}. `Sandbox.connect()` no longer
-   * calls this, so reconnecting to a running sandbox works without it.
+   * @deprecated Unsupported on Kubernetes. Use {@link Sandbox.connect} to
+   * reconnect to a running sandbox.
    */
   async resume(opts) {
     return SandboxClient.resumeSandbox(this.sandboxId, this.resolveOpts(opts));
@@ -1014,25 +1014,27 @@ var Sandbox = class extends SandboxClient {
     return SandboxClient.setTimeoutSandbox(this.sandboxId, timeoutMs, this.resolveOpts(opts));
   }
   /**
-   * Get the public HTTPS URL for a port exposed inside the sandbox.
+   * Register a public HTTPS route and return its hostname without a scheme.
    *
-   * Useful for accessing HTTP servers started inside the microVM from your
+   * Useful for accessing HTTP servers started inside the sandbox from your
    * agent or tests without additional tunneling.
    *
    * @example
    * ```ts
-   * await sandbox.process.exec('npx -y serve -p 3000 &')
-   * const url = sandbox.getHost(3000)
-   * // https://{sandboxId}-3000.sandbox.{region}.onlizard.com
+   * // Start an HTTP server on port 3000 before exposing it.
+   * const hostname = await sandbox.getHost(3000)
+   * console.log(`https://${hostname}`)
    * ```
    */
   async getHost(port, opts) {
     const { hostname } = await SandboxClient.exposeSandboxPort(this.sandboxId, port, this.resolveOpts(opts));
     return hostname;
   }
+  /** Fork is unsupported on Kubernetes; the backend returns HTTP 501. */
   fork(opts = {}) {
     return new PlatformClient(this.resolveOpts()).post(`/api/sandboxes/${this.sandboxId}/fork`, { count: opts.count ?? 1, timeoutMs: opts.timeoutMs ?? 0 });
   }
+  /** Snapshot creation is unsupported on Kubernetes; the backend returns HTTP 501. */
   snapshot(name) {
     return new PlatformClient(this.resolveOpts()).post(`/api/sandboxes/${this.sandboxId}/snapshot`, { name });
   }
@@ -1045,6 +1047,7 @@ var Sandbox = class extends SandboxClient {
   static snapshots(projectId, opts) {
     return new PlatformClient(opts ?? {}).get(`/api/projects/${projectId}/snapshots`);
   }
+  /** Snapshot restore is unsupported on Kubernetes; the backend returns HTTP 501. */
   static async restore(snapshotId, opts) {
     const result = await new PlatformClient(opts ?? {}).post(`/api/sandbox-snapshots/${encodeURIComponent(snapshotId)}/fork`, { timeoutMs: opts?.timeoutMs ?? 0 });
     return new this({ ...opts, sandboxId: result.sandboxId ?? result.id });
@@ -1157,7 +1160,7 @@ var AddonsAPI = class {
     });
     return this.get(projectId, addonId);
   }
-  /** Restart an addon VM. */
+  /** Restart an addon. */
   redeploy(projectId, addonId) {
     return this.client.post(`/api/projects/${projectId}/addons/${addonId}/redeploy`, {});
   }
@@ -1568,8 +1571,8 @@ var Volume = class _Volume {
    * exist yet. This is the reason a volume's name is its key: an agent that wants
    * "the scratch disk for this task" no longer has to store an id between runs.
    *
-   * An existing volume is returned as-is — `sizeGb` applies only to a fresh create
-   * and never resizes one that is already there.
+   * An existing volume is returned as-is — `sizeGb` applies only to a fresh create,
+   * so an existing volume keeps its size. Call {@link Volume.resize} to change it.
    */
   static async getOrCreate(projectId, name, opts) {
     const config = new ConnectionConfig(opts);
@@ -1609,6 +1612,32 @@ var Volume = class _Volume {
     });
     if (!res.ok) await handleApiError(res);
   }
+  /**
+   * Resize a volume, by name or by id, to `sizeGb`.
+   *
+   * The change is in place and online: the size is a quota, so no data is copied,
+   * it completes in well under a second, and a sandbox that has the volume mounted
+   * keeps running and sees the new size immediately. Both growing and shrinking are
+   * allowed, but a shrink must leave at least 10% of the new size free — otherwise
+   * it throws `ConflictError` with `code: 'volume_too_full_to_shrink'`.
+   *
+   * Other failures carry a `code` too: `invalid_volume_size`, `volume_not_resizable`,
+   * `volume_resize_in_progress`, `volume_not_provisioned`,
+   * `volume_capacity_unavailable`, and `volume_resize_timeout` (a `TimeoutError`;
+   * the size is left unchanged).
+   *
+   * @returns The volume's updated info, including `sizeEnforced`.
+   */
+  static async resize(projectId, nameOrId, sizeGb, opts) {
+    const config = new ConnectionConfig(opts);
+    const res = await fetch(`${config.apiUrl}/api/projects/${projectId}/volumes/${encodeURIComponent(nameOrId)}`, {
+      method: "PATCH",
+      headers: config.headers,
+      body: JSON.stringify({ sizeGb })
+    });
+    if (!res.ok) await handleApiError(res);
+    return res.json();
+  }
   async getInfo(projectId) {
     const res = await fetch(`${this.config.apiUrl}/api/projects/${projectId}/volumes/${this.volumeId}`, {
       headers: this.config.headers
@@ -1616,6 +1645,13 @@ var Volume = class _Volume {
     if (!res.ok) await handleApiError(res);
     return res.json();
   }
+  /** Resize this volume in place — see the static {@link Volume.resize}. */
+  async resize(projectId, sizeGb) {
+    return _Volume.resize(projectId, this.volumeId, sizeGb, {
+      apiKey: this.config.apiKey,
+      apiUrl: this.config.apiUrl
+    });
+  }
   async delete(projectId) {
     const res = await fetch(`${this.config.apiUrl}/api/projects/${projectId}/volumes/${this.volumeId}`, {
       method: "DELETE",
@@ -1649,6 +1685,7 @@ var Lizard = class {
       getOrCreate: async (name, opts) => Volume.getOrCreate(await this.projectId(), name, { ...await this.connectionOpts(), ...opts }),
       get: async (nameOrId, opts) => Volume.get(await this.projectId(), nameOrId, { ...await this.connectionOpts(), ...opts }),
       list: async (opts) => Volume.list(await this.projectId(), { ...await this.connectionOpts(), ...opts }),
+      resize: async (nameOrId, sizeGb, opts) => Volume.resize(await this.projectId(), nameOrId, sizeGb, { ...await this.connectionOpts(), ...opts }),
       delete: async (nameOrId, opts) => Volume.delete(await this.projectId(), nameOrId, { ...await this.connectionOpts(), ...opts })
     };
     this.config = new ConnectionConfig(opts);
@@ -1759,8 +1796,7 @@ var CodeSandbox = class extends Sandbox {
    *
    * @returns Execution result with stdout, stderr, results, and any error.
    *
-   * @throws {ExecutionError} if you pass neither language nor context and no
-   *   default context exists — which cannot happen in normal usage.
+   * Code errors appear in `execution.error`; request failures throw.
    *
    * @example
    * ```ts