@lizard-build/sdk 0.1.68 → 0.1.70

package/README.md

@@ -1,6 +1,6 @@
 # Lizard SDK for TypeScript
 
-Run commands, work with files and execute code in Linux sandboxes (Firecracker microVMs). The SDK also manages Lizard apps, databases, storage and projects.
+Run commands, work with files and execute code in Linux sandboxes with Firecracker support. The SDK also manages Lizard apps, databases, storage and projects.
 
 ## Install
 
@@ -40,7 +40,7 @@ The package includes TypeScript declarations and ESM and CommonJS builds. For Co
 
 ## Machine size
 
-Sandboxes come in three sizes: `small` (2 vCPU / 4 GB, $0.0162/h), `medium` (4 vCPU / 8 GB, $0.0324/h, the default) and `large` (8 vCPU / 16 GB, $0.0648/h). Billing is flat by size, per second while the sandbox runs; measured CPU/RAM are not charged, egress is free, and volumes bill separately.
+Sandboxes come in three sizes: `small` (2 vCPU / 4 GB, $0.0162/h), `medium` (4 vCPU / 8 GB, $0.0324/h, the default) and `large` (8 vCPU / 16 GB, $0.0648/h). Billing is flat by size, per second while the sandbox runs, including idle time. CPU and RAM are included. The sandbox egress allowance is [2 TB per account over a rolling 30 days](https://lizard.build/docs/platform/limits/#sandbox-egress), with no separate per-GB charge. A successful pause stops compute charges; storage in Persistent Volumes is billed separately, including while paused.
 
 ```ts
 const sandbox = await lizard.create('base', { size: 'large' })
@@ -125,7 +125,7 @@ Pass `timeoutMs` to `create()` to set the sandbox lifetime. The default is five
 
 ## Runtime limits
 
-Each sandbox is a Firecracker microVM with its own kernel. Use volumes mounted at `/workspace` to keep files after a sandbox ends. `pause()`/`resume()` keep memory and running processes; `snapshot()` is ready in about 2 s and `Sandbox.restore()` starts a copy in about 0.4 s; `fork()` clones a running sandbox. File watching and sandbox log streaming are not available on Firecracker sandboxes yet. Volumes can grow but not shrink, and a sandbox with a volume attached cannot be forked. See the [snapshot guide](../../docs/sandboxes.md#pause-resume-snapshots-and-fork).
+Lizard Sandboxes support Firecracker microVMs with their own kernel. Older pod volumes or snapshots, account or region settings, and some Firecracker startup failures can select a container that shares the host kernel. Check `getInfo().runtime` in TypeScript or `get_info().runtime` in Python before running code that requires a separate kernel. Use volumes mounted at `/workspace` to keep files after a sandbox ends. `pause()`/`resume()` keep memory and running processes; `snapshot()` is ready in about 2 s and `Sandbox.restore()` starts a copy in about 0.4 s; `fork()` clones a running sandbox. File watching and sandbox log streaming are not available on Firecracker sandboxes yet. Volumes can grow but not shrink, and a sandbox with a volume attached cannot be forked. See the [snapshot guide](../../docs/sandboxes.md#pause-resume-snapshots-and-fork).
 
 `getHost()` returns a hostname without `https://`; the port is private, so send `sandbox.accessToken` as the `X-Lizard-Access-Token` header (or use `exposePort()`, which also returns a browser `url` carrying the token). File writes accept text or bytes (binary is sent exactly); `readBytes()` supports binary downloads.
 

package/dist/index.d.mts

@@ -911,7 +911,10 @@ interface SandboxOpts extends ConnectionOpts {
      * - `'medium'` — 4 vCPU / 8 GB, $0.0324/h (default)
      * - `'large'`  — 8 vCPU / 16 GB, $0.0648/h
      *
-     * Measured CPU/RAM are not charged and egress is free. Ignored with {@link SandboxOpts.snapshotId}.
+     * CPU/RAM are included; running time includes idle time. Sandbox egress includes 2 TB per
+     * account over a rolling 30 days: https://lizard.build/docs/platform/limits/#sandbox-egress
+     * A successful pause stops compute charges; Persistent Volumes storage bills separately.
+     * Ignored with {@link SandboxOpts.snapshotId}.
      */
     size?: 'small' | 'medium' | 'large';
     /** Your own key/value labels for the sandbox, returned by `getInfo()` and `list()`. */
@@ -1494,12 +1497,16 @@ interface WorkspaceLimits {
     maxCpuVcpus: number | null;
     /** Memory (MB) its apps and databases may be using right now (measured). */
     maxMemoryMb: number | null;
+    /** SSD (GB) its databases and volumes may hold (measured: data written, not sizes asked for). */
+    maxDiskGb: number | null;
 }
 interface WorkspaceUsage {
     runningSandboxes: number;
     /** Measured, all regions, its apps and databases. */
     cpuVcpus: number;
     memoryMb: number;
+    /** SSD (GB) its databases and volumes hold, last measurement of each. */
+    diskGb: number;
     /** Unix ms of the oldest reading in the sum; null when nothing was measured. */
     measuredAt: number | null;
 }
@@ -1587,9 +1594,12 @@ declare class WorkspacesAPI {
      *   not their configured limits). While at or over a cap, deploys, redeploys, restarts,
      *   scale-ups, new databases and resumes there fail with HTTP 429 `WORKSPACE_USAGE_LIMIT`;
      *   services already running keep running.
+     * - `maxDiskGb`: the SSD its databases and volumes hold (measured, not their sizes). While at
+     *   or over it, new volumes, volume growth, new databases and template deploys fail with
+     *   HTTP 429 `WORKSPACE_USAGE_LIMIT`; data already written stays.
      *
      * ```ts
-     * await lizard.workspaces.setLimits(ws.id, { maxRunningSandboxes: 5, maxCpuVcpus: 2, maxMemoryMb: 4096 })
+     * await lizard.workspaces.setLimits(ws.id, { maxRunningSandboxes: 5, maxCpuVcpus: 2, maxMemoryMb: 4096, maxDiskGb: 20 })
      * ```
      */
     setLimits(id: string, limits: Partial<WorkspaceLimits>): Promise<WorkspaceLimitsInfo>;
@@ -2274,6 +2284,7 @@ declare class LimitExceededError extends LizardError {
         runningSandboxes: number;
         cpuVcpus: number;
         memoryMb: number;
+        diskGb?: number;
         measuredAt: number | null;
     };
     /** `WORKSPACE_USAGE_LIMIT`: the workspace's limits. */
@@ -2281,6 +2292,7 @@ declare class LimitExceededError extends LizardError {
         maxRunningSandboxes: number | null;
         maxCpuVcpus: number | null;
         maxMemoryMb: number | null;
+        maxDiskGb?: number | null;
     };
     constructor(message?: string);
 }

package/dist/index.d.ts

@@ -911,7 +911,10 @@ interface SandboxOpts extends ConnectionOpts {
      * - `'medium'` — 4 vCPU / 8 GB, $0.0324/h (default)
      * - `'large'`  — 8 vCPU / 16 GB, $0.0648/h
      *
-     * Measured CPU/RAM are not charged and egress is free. Ignored with {@link SandboxOpts.snapshotId}.
+     * CPU/RAM are included; running time includes idle time. Sandbox egress includes 2 TB per
+     * account over a rolling 30 days: https://lizard.build/docs/platform/limits/#sandbox-egress
+     * A successful pause stops compute charges; Persistent Volumes storage bills separately.
+     * Ignored with {@link SandboxOpts.snapshotId}.
      */
     size?: 'small' | 'medium' | 'large';
     /** Your own key/value labels for the sandbox, returned by `getInfo()` and `list()`. */
@@ -1494,12 +1497,16 @@ interface WorkspaceLimits {
     maxCpuVcpus: number | null;
     /** Memory (MB) its apps and databases may be using right now (measured). */
     maxMemoryMb: number | null;
+    /** SSD (GB) its databases and volumes may hold (measured: data written, not sizes asked for). */
+    maxDiskGb: number | null;
 }
 interface WorkspaceUsage {
     runningSandboxes: number;
     /** Measured, all regions, its apps and databases. */
     cpuVcpus: number;
     memoryMb: number;
+    /** SSD (GB) its databases and volumes hold, last measurement of each. */
+    diskGb: number;
     /** Unix ms of the oldest reading in the sum; null when nothing was measured. */
     measuredAt: number | null;
 }
@@ -1587,9 +1594,12 @@ declare class WorkspacesAPI {
      *   not their configured limits). While at or over a cap, deploys, redeploys, restarts,
      *   scale-ups, new databases and resumes there fail with HTTP 429 `WORKSPACE_USAGE_LIMIT`;
      *   services already running keep running.
+     * - `maxDiskGb`: the SSD its databases and volumes hold (measured, not their sizes). While at
+     *   or over it, new volumes, volume growth, new databases and template deploys fail with
+     *   HTTP 429 `WORKSPACE_USAGE_LIMIT`; data already written stays.
      *
      * ```ts
-     * await lizard.workspaces.setLimits(ws.id, { maxRunningSandboxes: 5, maxCpuVcpus: 2, maxMemoryMb: 4096 })
+     * await lizard.workspaces.setLimits(ws.id, { maxRunningSandboxes: 5, maxCpuVcpus: 2, maxMemoryMb: 4096, maxDiskGb: 20 })
      * ```
      */
     setLimits(id: string, limits: Partial<WorkspaceLimits>): Promise<WorkspaceLimitsInfo>;
@@ -2274,6 +2284,7 @@ declare class LimitExceededError extends LizardError {
         runningSandboxes: number;
         cpuVcpus: number;
         memoryMb: number;
+        diskGb?: number;
         measuredAt: number | null;
     };
     /** `WORKSPACE_USAGE_LIMIT`: the workspace's limits. */
@@ -2281,6 +2292,7 @@ declare class LimitExceededError extends LizardError {
         maxRunningSandboxes: number | null;
         maxCpuVcpus: number | null;
         maxMemoryMb: number | null;
+        maxDiskGb?: number | null;
     };
     constructor(message?: string);
 }

package/dist/index.js

@@ -1786,9 +1786,12 @@ var WorkspacesAPI = class {
    *   not their configured limits). While at or over a cap, deploys, redeploys, restarts,
    *   scale-ups, new databases and resumes there fail with HTTP 429 `WORKSPACE_USAGE_LIMIT`;
    *   services already running keep running.
+   * - `maxDiskGb`: the SSD its databases and volumes hold (measured, not their sizes). While at
+   *   or over it, new volumes, volume growth, new databases and template deploys fail with
+   *   HTTP 429 `WORKSPACE_USAGE_LIMIT`; data already written stays.
    *
    * ```ts
-   * await lizard.workspaces.setLimits(ws.id, { maxRunningSandboxes: 5, maxCpuVcpus: 2, maxMemoryMb: 4096 })
+   * await lizard.workspaces.setLimits(ws.id, { maxRunningSandboxes: 5, maxCpuVcpus: 2, maxMemoryMb: 4096, maxDiskGb: 20 })
    * ```
    */
   setLimits(id, limits) {

package/dist/index.mjs

@@ -1732,9 +1732,12 @@ var WorkspacesAPI = class {
    *   not their configured limits). While at or over a cap, deploys, redeploys, restarts,
    *   scale-ups, new databases and resumes there fail with HTTP 429 `WORKSPACE_USAGE_LIMIT`;
    *   services already running keep running.
+   * - `maxDiskGb`: the SSD its databases and volumes hold (measured, not their sizes). While at
+   *   or over it, new volumes, volume growth, new databases and template deploys fail with
+   *   HTTP 429 `WORKSPACE_USAGE_LIMIT`; data already written stays.
    *
    * ```ts
-   * await lizard.workspaces.setLimits(ws.id, { maxRunningSandboxes: 5, maxCpuVcpus: 2, maxMemoryMb: 4096 })
+   * await lizard.workspaces.setLimits(ws.id, { maxRunningSandboxes: 5, maxCpuVcpus: 2, maxMemoryMb: 4096, maxDiskGb: 20 })
    * ```
    */
   setLimits(id, limits) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lizard-build/sdk",
-  "version": "0.1.68",
+  "version": "0.1.70",
   "description": "TypeScript SDK for Lizard: Firecracker microVM sandboxes, code execution and cloud apps.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",