@blaxel/core 0.3.8-preview.233 → 0.3.8-preview.234

package/dist/cjs/common/settings.js

@@ -30,8 +30,8 @@ function missingCredentialsMessage() {
     return "No Blaxel credentials found. Set the BL_API_KEY and BL_WORKSPACE environment variables, or run `bl login`.";
 }
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.3.8-preview.233";
-const BUILD_COMMIT = "816aea9abd2e04956ff3e83f01b8f838e9486f71";
+const BUILD_VERSION = "0.3.8-preview.234";
+const BUILD_COMMIT = "640ca44f9533691231a7903a1685eb57c244a43d";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-04-28";
 // Bun < 1.3.11 never sends connection-level WINDOW_UPDATE: the pooled h2

package/dist/cjs/sandbox/sandbox.js

@@ -164,6 +164,64 @@ class SandboxInstance {
     async fetch(port, path = "/", init) {
         return this.network.fetch(port, path, init);
     }
+    /**
+     * Create a point-in-time snapshot of this sandbox. Snapshots capture the
+     * sandbox state and can be forked into new sandboxes or applications.
+     *
+     * @param name - Optional human-readable name for the snapshot.
+     */
+    async snapshot(name) {
+        const { data } = await (0, index_js_1.createSandboxSnapshot)({
+            path: { sandboxName: this.metadata.name },
+            body: name ? { name } : {},
+            throwOnError: true,
+        });
+        return data;
+    }
+    /**
+     * List the snapshots of this sandbox.
+     */
+    async listSnapshots() {
+        const { data } = await (0, index_js_1.listSandboxSnapshots)({
+            path: { sandboxName: this.metadata.name },
+            throwOnError: true,
+        });
+        return data;
+    }
+    /**
+     * Delete a snapshot of this sandbox by its ID.
+     */
+    async deleteSnapshot(snapshotId) {
+        await (0, index_js_1.deleteSandboxSnapshot)({
+            path: { sandboxName: this.metadata.name, snapshotId },
+            throwOnError: true,
+        });
+    }
+    /**
+     * Fork this sandbox into a new sandbox or application.
+     *
+     * Pass `snapshotId` to fork from a specific snapshot (create a sandbox from a
+     * snapshot) instead of the sandbox's live state.
+     *
+     * @param targetName - Name of the sandbox/application to create.
+     * @param options - Fork options (target type, port, traffic, snapshot, ...).
+     */
+    async fork(targetName, options = {}) {
+        const { data } = await (0, index_js_1.forkSandbox)({
+            path: { sandboxName: this.metadata.name },
+            body: {
+                targetName,
+                targetType: options.targetType ?? "sandbox",
+                ...(options.port !== undefined ? { port: options.port } : {}),
+                ...(options.traffic !== undefined ? { traffic: options.traffic } : {}),
+                ...(options.customDomain !== undefined ? { customDomain: options.customDomain } : {}),
+                ...(options.prefix !== undefined ? { prefix: options.prefix } : {}),
+                ...(options.snapshotId !== undefined ? { snapshotId: options.snapshotId } : {}),
+            },
+            throwOnError: true,
+        });
+        return data;
+    }
     /* eslint-disable */
     async wait({ maxWait = 60000, interval = 1000 } = {}) {
         logger_js_1.logger.warn("⚠️  Warning: sandbox.wait() is deprecated. You don't need to wait for the sandbox to be deployed anymore.");

package/dist/cjs/types/sandbox/sandbox.d.ts

@@ -1,5 +1,5 @@
 import type http2 from "http2";
-import { type ListSandboxesData, type SandboxLifecycle, type Sandbox as SandboxModel } from "../client/index.js";
+import { type ListSandboxesData, type SandboxForkResponse, type SandboxLifecycle, type Sandbox as SandboxModel, type SandboxSnapshot, type SandboxSnapshots } from "../client/index.js";
 import { SandboxCodegen } from "./codegen/index.js";
 import { SandboxDrive } from "./drive/index.js";
 import { SandboxFileSystem } from "./filesystem/index.js";
@@ -11,6 +11,24 @@ import { SandboxSessions } from "./session.js";
 import { SandboxSystem } from "./system.js";
 import { SandboxConfiguration, SandboxCreateConfiguration, SandboxUpdateMetadata, SandboxUpdateNetwork, SessionWithToken } from "./types.js";
 export type SandboxListQuery = NonNullable<ListSandboxesData["query"]>;
+export type SandboxForkOptions = {
+    /** Resource type to fork into. Defaults to "sandbox". */
+    targetType?: "sandbox" | "application";
+    /** Port to expose from the fork. */
+    port?: number;
+    /** Canary traffic percentage (0-100) when forking into an application. */
+    traffic?: number;
+    /** Custom domain for the application fork. */
+    customDomain?: string;
+    /** URL prefix for the application fork. */
+    prefix?: string;
+    /**
+     * Snapshot ID to fork from. When set, the fork is created from this snapshot
+     * instead of the source sandbox's live state — this is how you create a
+     * sandbox from a snapshot.
+     */
+    snapshotId?: string;
+};
 export declare class SandboxInstance {
     private sandbox;
     fs: SandboxFileSystem;
@@ -45,6 +63,31 @@ export declare class SandboxInstance {
      * @param init - Standard RequestInit options forwarded to fetch
      */
     fetch(port: number, path?: string, init?: RequestInit): Promise<Response>;
+    /**
+     * Create a point-in-time snapshot of this sandbox. Snapshots capture the
+     * sandbox state and can be forked into new sandboxes or applications.
+     *
+     * @param name - Optional human-readable name for the snapshot.
+     */
+    snapshot(name?: string): Promise<SandboxSnapshot>;
+    /**
+     * List the snapshots of this sandbox.
+     */
+    listSnapshots(): Promise<SandboxSnapshots>;
+    /**
+     * Delete a snapshot of this sandbox by its ID.
+     */
+    deleteSnapshot(snapshotId: string): Promise<void>;
+    /**
+     * Fork this sandbox into a new sandbox or application.
+     *
+     * Pass `snapshotId` to fork from a specific snapshot (create a sandbox from a
+     * snapshot) instead of the sandbox's live state.
+     *
+     * @param targetName - Name of the sandbox/application to create.
+     * @param options - Fork options (target type, port, traffic, snapshot, ...).
+     */
+    fork(targetName: string, options?: SandboxForkOptions): Promise<SandboxForkResponse>;
     wait({ maxWait, interval }?: {
         maxWait?: number;
         interval?: number;