@aerol-ai/aerolvm-sdk 0.8.1 → 0.8.2

package/dist/MicroVM.js

@@ -4,10 +4,8 @@ const defaultAPIURL = "http://127.0.0.1:21212";
 const authRequiredErrorMessage = "PAT token is required. Set patToken, SB_PAT_TOKEN or SB_API_TOKEN.";
 export class MicroVM {
     apiUrl;
-    patToken;
     /** The team sent as `X-AerolVM-Team`, or `""` when none is. */
     team;
-    client;
     constructor(config = {}) {
         const patToken = config.patToken ?? readEnv("SB_PAT_TOKEN") ?? readEnv("SB_API_TOKEN") ?? "";
         const apiUrl = normalizeURL(config.apiUrl ?? readEnv("SB_API_URL") ?? defaultAPIURL);
@@ -16,9 +14,9 @@ export class MicroVM {
             throw new Error(authRequiredErrorMessage);
         }
         this.apiUrl = apiUrl;
-        this.patToken = patToken;
+        Object.defineProperty(this, "patToken", { value: patToken, enumerable: false });
         this.team = team;
-        this.client = new APIClient({
+        const client = new APIClient({
             baseURL: apiUrl,
             patToken,
             team,
@@ -27,26 +25,29 @@ export class MicroVM {
             retry: config.retry,
             signal: config.signal,
         });
+        Object.defineProperty(this, "client", { value: client, enumerable: false });
     }
-    async create(options) {
-        const sandbox = await this.client.create(options);
-        return this.wrap(sandbox.toJSON());
+    async create(options, call) {
+        const sandbox = await this.clientFor(call).create(options);
+        const wrapped = this.wrap(sandbox.toJSON());
+        wrapped.destroyOnExit = options.destroyOnExit ?? false;
+        return wrapped;
     }
-    async list(options) {
-        const sandboxes = await this.client.list(options);
+    async list(options, call) {
+        const sandboxes = await this.clientFor(call).list(options);
         return sandboxes.map((sandbox) => this.wrap(sandbox.toJSON()));
     }
     /**
      * Iterates one server page at a time. Use this for large fleet inventories so
      * the SDK does not retain every sandbox in memory.
      */
-    async *listPages(options) {
-        for await (const page of this.client.listPages(options)) {
+    async *listPages(options, call) {
+        for await (const page of this.clientFor(call).listPages(options)) {
             yield page.map((sandbox) => this.wrap(sandbox.toJSON()));
         }
     }
-    async get(id, options) {
-        const sandbox = await this.client.get(id, options);
+    async get(id, options, call) {
+        const sandbox = await this.clientFor(call).get(id, options);
         return this.wrap(sandbox.toJSON());
     }
     /**
@@ -54,52 +55,81 @@ export class MicroVM {
      * Names are unique per owner. Throws when the server predates name lookup
      * (it ignores `?name=`), rather than guessing from an unfiltered list.
      */
-    async getByName(name, options) {
-        const sandbox = await this.client.getByName(name, options);
+    async getByName(name, options, call) {
+        const sandbox = await this.clientFor(call).getByName(name, options);
         return sandbox === null ? null : this.wrap(sandbox.toJSON());
     }
-    async start(id) {
-        const sandbox = await this.client.start(id);
+    /**
+     * Returns the caller's sandbox called `name`, creating it from `options`
+     * when there is none. `created` is true only when this call made the
+     * sandbox. Safe to retry and to run at the same time from many processes:
+     * names are unique per owner, so when two callers race to create the same
+     * name, one gets a 409 and reads the winner's sandbox instead. An existing
+     * sandbox is returned as it is; its image and settings are not compared
+     * with `options`.
+     */
+    async getOrCreate(name, options, call) {
+        const result = await this.clientFor(call).getOrCreate(name, options);
+        const sandbox = this.wrap(result.sandbox.toJSON());
+        // destroyOnExit applies only to a sandbox this call created. One it found
+        // may be in use by another program that shares the name.
+        sandbox.destroyOnExit = result.created ? (options.destroyOnExit ?? false) : false;
+        return { sandbox, created: result.created };
+    }
+    async start(id, call) {
+        const sandbox = await this.clientFor(call).start(id);
         return this.wrap(sandbox.toJSON());
     }
-    async stop(id) {
-        const sandbox = await this.client.stop(id);
+    async stop(id, call) {
+        const sandbox = await this.clientFor(call).stop(id);
         return this.wrap(sandbox.toJSON());
     }
-    async createSnapshot(id, name, options = {}) {
-        return this.client.createSnapshot(id, name, options);
+    async createSnapshot(id, name, options = {}, call) {
+        return this.clientFor(call).createSnapshot(id, name, options);
     }
-    async registerSnapshot(options) {
-        return this.client.registerSnapshot(options);
+    async registerSnapshot(options, call) {
+        return this.clientFor(call).registerSnapshot(options);
     }
-    async registerSnapshotFromImage(name, image, options = {}) {
-        return this.client.registerSnapshotFromImage(name, image, options);
+    async registerSnapshotFromImage(name, image, options = {}, call) {
+        return this.clientFor(call).registerSnapshotFromImage(name, image, options);
     }
     /** Look a snapshot up by name. In a cluster the request is routed to the node holding the image. */
-    async getSnapshot(name) {
-        return this.client.getSnapshot(name);
+    async getSnapshot(name, call) {
+        return this.clientFor(call).getSnapshot(name);
     }
     /** List the caller's snapshots, one name-ordered page at a time. */
-    async listSnapshots(options = {}) {
-        return this.client.listSnapshots(options);
+    async listSnapshots(options = {}, call) {
+        return this.clientFor(call).listSnapshots(options);
     }
     /** Delete a snapshot by name (idempotent 404 if it does not exist). */
-    async deleteSnapshot(name) {
-        return this.client.deleteSnapshot(name);
+    async deleteSnapshot(name, call) {
+        return this.clientFor(call).deleteSnapshot(name);
+    }
+    async destroy(id, call) {
+        await this.clientFor(call).destroy(id);
     }
-    async destroy(id) {
-        await this.client.destroy(id);
+    /**
+     * Deletes every sandbox of yours that carries all of `options.tags` and
+     * returns the IDs of the ones now gone. It lists every page first, then
+     * deletes them one at a time. A sandbox that is already gone (404) counts
+     * as deleted, so a second call, or two calls at once, is safe. Any other
+     * failed delete stops the call and is thrown; the sandboxes already
+     * deleted stay deleted, and calling it again finishes the job. `tags`
+     * must not be empty.
+     */
+    async destroyAll(options, call) {
+        return this.clientFor(call).destroyAll(options.tags);
     }
-    async resize(id, options) {
-        const sandbox = await this.client.resize(id, options);
+    async resize(id, options, call) {
+        const sandbox = await this.clientFor(call).resize(id, options);
         return this.wrap(sandbox.toJSON());
     }
-    async updateLifecycle(id, lifecycle) {
-        const sandbox = await this.client.updateLifecycle(id, lifecycle);
+    async updateLifecycle(id, lifecycle, call) {
+        const sandbox = await this.clientFor(call).updateLifecycle(id, lifecycle);
         return this.wrap(sandbox.toJSON());
     }
-    async reconcile() {
-        await this.client.reconcile();
+    async reconcile(call) {
+        await this.clientFor(call).reconcile();
     }
     /**
      * Build an {@link Image} on the daemon and optionally push the result to a
@@ -107,40 +137,103 @@ export class MicroVM {
      * persisted by the daemon. Returns the local content-addressed tag and,
      * when push was requested, the pushed reference.
      */
-    async buildImage(image, options) {
-        return this.client.buildImage(image, options);
+    async buildImage(image, options, call) {
+        return this.clientFor(call).buildImage(image, options);
     }
-    async health() {
-        return this.client.health();
+    async health(call) {
+        return this.clientFor(call).health();
     }
     /**
      * Asks whether a sandbox created with these egress fields would reach a
      * destination, using the same matcher the filter enforces. No sandbox is
      * needed.
      */
-    async checkNetworkPolicy(options) {
-        return this.client.checkNetworkPolicy(options);
+    async checkNetworkPolicy(options, call) {
+        return this.clientFor(call).checkNetworkPolicy(options);
     }
     /**
      * Creates or replaces a named egress profile (a full replace: the same body
      * twice is a no-op). Sandboxes reference it through `egressProfiles`, and a
      * change reaches every one of them.
      */
-    async putEgressProfile(name, options) {
-        return this.client.putEgressProfile(name, options);
+    async putEgressProfile(name, options, call) {
+        return this.clientFor(call).putEgressProfile(name, options);
     }
-    async getEgressProfile(name) {
-        return this.client.getEgressProfile(name);
+    async getEgressProfile(name, call) {
+        return this.clientFor(call).getEgressProfile(name);
     }
-    async listEgressProfiles(options) {
-        return this.client.listEgressProfiles(options);
+    async listEgressProfiles(options, call) {
+        return this.clientFor(call).listEgressProfiles(options);
     }
     /** Deletes a profile; one that sandboxes still reference is refused (409). */
-    async deleteEgressProfile(name) {
-        return this.client.deleteEgressProfile(name);
+    async deleteEgressProfile(name, call) {
+        return this.clientFor(call).deleteEgressProfile(name);
+    }
+    /**
+     * Sets how many ready sandboxes every server with a warm pool keeps for an
+     * image (a full replace: the same call twice is a no-op). A create that names
+     * the image then starts from a warm sandbox. Admin only.
+     */
+    async putWarmPool(image, options, call) {
+        return this.clientFor(call).putWarmPool(image, options);
+    }
+    /** Returns an image's warm-pool entry with its status (ready and target, per server). */
+    async getWarmPool(image, call) {
+        return this.clientFor(call).getWarmPool(image);
+    }
+    /** Returns every warm-pool entry, by image, with its status. */
+    async listWarmPools(call) {
+        return this.clientFor(call).listWarmPools();
+    }
+    /** Deletes an image's warm-pool entry; its warm sandboxes are removed. Deleting a missing entry succeeds. */
+    async deleteWarmPool(image, call) {
+        return this.clientFor(call).deleteWarmPool(image);
     }
-    async mounts(sandboxID) {
-        return this.client.mounts(sandboxID);
+    /**
+     * Puts a role tag on a team's cloud identity allow list, or changes its
+     * minimum caller role (`"runner"` or `"admin"`). Admin only. The same call
+     * twice changes nothing, so it is safe to retry.
+     */
+    async putIdentityRole(tag, options, call) {
+        return this.clientFor(call).putIdentityRole(tag, options);
+    }
+    /** Lists a team's cloud identity allow list, one page at a time. Admin only. */
+    async listIdentityRoles(options, call) {
+        return this.clientFor(call).listIdentityRoles(options);
+    }
+    /**
+     * Takes a role tag off a team's allow list. Admin only. Sandboxes that use
+     * it keep their current token (at most one hour) and get no new one.
+     * Deleting a tag that is already gone succeeds.
+     */
+    async deleteIdentityRole(tag, options, call) {
+        return this.clientFor(call).deleteIdentityRole(tag, options);
+    }
+    /**
+     * Sets a team's quota: the most sandboxes, CPU and memory its sandboxes
+     * may hold. Admin only. The same limits twice change nothing. A create,
+     * resize or start past the quota fails with 429 `team_quota_exceeded`.
+     */
+    async putTeamQuota(team, options, call) {
+        return this.clientFor(call).putTeamQuota(team, options);
+    }
+    /** Reads a team's quota and what the team holds now. 404 if it has none. */
+    async getTeamQuota(team, call) {
+        return this.clientFor(call).getTeamQuota(team);
+    }
+    /** Removes a team's quota. Removing one that is already gone succeeds. */
+    async deleteTeamQuota(team, call) {
+        return this.clientFor(call).deleteTeamQuota(team);
+    }
+    async mounts(sandboxID, call) {
+        return this.clientFor(call).mounts(sandboxID);
+    }
+    /**
+     * Make every token issued for a sandbox so far stop working (see
+     * `sandbox.revokeTokens()`). A token made after the call works.
+     */
+    async revokeSandboxTokens(sandboxID, call) {
+        return this.clientFor(call).revokeSandboxTokens(sandboxID);
     }
     /**
      * Read a sandbox's clone-generation token. The token changes whenever the
@@ -148,35 +241,46 @@ export class MicroVM {
      * Read-only — the SDK cannot reseed a process inside the guest; see the
      * "Randomness in cloned sandboxes" docs page for the in-guest reseed pattern.
      */
-    async cloneGeneration(sandboxID) {
-        return this.client.cloneGeneration(sandboxID);
+    async cloneGeneration(sandboxID, call) {
+        return this.clientFor(call).cloneGeneration(sandboxID);
     }
     execStream(sandboxID, options) {
         return this.client.execStream(sandboxID, options);
     }
-    async createSession(sandboxID, options) {
-        return this.client.createSession(sandboxID, options);
+    /**
+     * Watch a folder in a sandbox for changes: `onEvent` gets each create,
+     * write, remove, rename and chmod, in batches every 250 ms. Resolves once
+     * the watch is in place. gVisor and Firecracker sandboxes only; Docker,
+     * containerd, WASM and isolate sandboxes reject with a 501
+     * `MicroVMApiError`. A sandbox whose agent predates file watching rejects
+     * with `MicroVMUnsupportedFeatureError`.
+     */
+    async watchFiles(sandboxID, path, onEvent, options = {}) {
+        return this.client.watchFiles(sandboxID, path, onEvent, options);
+    }
+    async createSession(sandboxID, options, call) {
+        return this.clientFor(call).createSession(sandboxID, options);
     }
-    async listSessions(sandboxID) {
-        return this.client.listSessions(sandboxID);
+    async listSessions(sandboxID, call) {
+        return this.clientFor(call).listSessions(sandboxID);
     }
-    async getSession(sandboxID, sessionID) {
-        return this.client.getSession(sandboxID, sessionID);
+    async getSession(sandboxID, sessionID, call) {
+        return this.clientFor(call).getSession(sandboxID, sessionID);
     }
-    async deleteSession(sandboxID, sessionID) {
-        await this.client.deleteSession(sandboxID, sessionID);
+    async deleteSession(sandboxID, sessionID, call) {
+        await this.clientFor(call).deleteSession(sandboxID, sessionID);
     }
-    async signalSession(sandboxID, sessionID, signal) {
-        await this.client.signalSession(sandboxID, sessionID, signal);
+    async signalSession(sandboxID, sessionID, signal, call) {
+        await this.clientFor(call).signalSession(sandboxID, sessionID, signal);
     }
-    async resizeSession(sandboxID, sessionID, cols, rows) {
-        await this.client.resizeSession(sandboxID, sessionID, cols, rows);
+    async resizeSession(sandboxID, sessionID, cols, rows, call) {
+        await this.clientFor(call).resizeSession(sandboxID, sessionID, cols, rows);
     }
-    async sessionLog(sandboxID, sessionID) {
-        return this.client.sessionLog(sandboxID, sessionID);
+    async sessionLog(sandboxID, sessionID, call) {
+        return this.clientFor(call).sessionLog(sandboxID, sessionID);
     }
-    async sessionRecording(sandboxID, sessionID) {
-        return this.client.sessionRecording(sandboxID, sessionID);
+    async sessionRecording(sandboxID, sessionID, call) {
+        return this.clientFor(call).sessionRecording(sandboxID, sessionID);
     }
     attachSession(sandboxID, sessionID, options = {}) {
         return this.client.attachSession(sandboxID, sessionID, options);
@@ -191,42 +295,42 @@ export class MicroVM {
      * duplicate ID returns 409 so a retried CI step does not create two
      * rows for the same logical template.
      */
-    async createTemplate(options) {
-        return this.client.createTemplate(options);
+    async createTemplate(options, call) {
+        return this.clientFor(call).createTemplate(options);
     }
-    async listTemplates() {
-        return this.client.listTemplates();
+    async listTemplates(call) {
+        return this.clientFor(call).listTemplates();
     }
-    async getTemplate(id) {
-        return this.client.getTemplate(id);
+    async getTemplate(id, call) {
+        return this.clientFor(call).getTemplate(id);
     }
-    async deleteTemplate(id) {
-        await this.client.deleteTemplate(id);
+    async deleteTemplate(id, call) {
+        await this.clientFor(call).deleteTemplate(id);
     }
     /**
      * Register a WASM module in the host catalogue. Resolution is synchronous —
      * the returned row is typically already `ready`. Use the row's `id` or
      * `moduleRef` on subsequent `create` calls with `runtime: "wasm"`.
      */
-    async createWasmModule(options) {
-        return this.client.createWasmModule(options);
+    async createWasmModule(options, call) {
+        return this.clientFor(call).createWasmModule(options);
     }
-    async listWasmModules() {
-        return this.client.listWasmModules();
+    async listWasmModules(call) {
+        return this.clientFor(call).listWasmModules();
     }
-    async getWasmModule(id) {
-        return this.client.getWasmModule(id);
+    async getWasmModule(id, call) {
+        return this.clientFor(call).getWasmModule(id);
     }
-    async deleteWasmModule(id) {
-        await this.client.deleteWasmModule(id);
+    async deleteWasmModule(id, call) {
+        await this.clientFor(call).deleteWasmModule(id);
     }
     /**
      * Upload a compiled core-wasip1 module to the registry under your own
      * credentials and get back the `oci://` ref to use as `moduleRef` on create.
      * The daemon validates and forwards the bytes; it never stores them.
      */
-    async pushWasmModule(options) {
-        return this.client.pushWasmModule(options);
+    async pushWasmModule(options, call) {
+        return this.clientFor(call).pushWasmModule(options);
     }
     /**
      * Re-run the snapshot phase against an existing template. Idempotent
@@ -239,8 +343,8 @@ export class MicroVM {
      * where rebuild is not safe (build in flight) or not supported
      * (`ready_no_snapshot` / `failed` — those need delete+recreate today).
      */
-    async rebuildTemplate(id) {
-        return this.client.rebuildTemplate(id);
+    async rebuildTemplate(id, call) {
+        return this.clientFor(call).rebuildTemplate(id);
     }
     /**
      * Cluster-level DNS helpers. Exposed as a namespaced accessor (rather
@@ -252,15 +356,15 @@ export class MicroVM {
     get dns() {
         const client = this.client;
         return {
-            target: () => client.ingressDNS(),
+            target: (call) => client.withSignal(call?.signal).ingressDNS(),
         };
     }
     /**
      * Who the server says the caller is: principal, role, team and when the
      * credential expires. Every valid credential may ask.
      */
-    async whoami() {
-        return this.client.whoami();
+    async whoami(call) {
+        return this.clientFor(call).whoami();
     }
     /**
      * Scoped API tokens (`avm_…`) for services and CI, as
@@ -270,11 +374,15 @@ export class MicroVM {
     get tokens() {
         const client = this.client;
         return {
-            create: (options) => client.createAPIToken(options),
-            list: () => client.listAPITokens(),
-            revoke: (id) => client.revokeAPIToken(id),
+            create: (options, call) => client.withSignal(call?.signal).createAPIToken(options),
+            list: (call) => client.withSignal(call?.signal).listAPITokens(),
+            revoke: (id, call) => client.withSignal(call?.signal).revokeAPIToken(id),
         };
     }
+    /** The client for one call: the real one, or a view carrying the call's signal. */
+    clientFor(call) {
+        return this.client.withSignal(call?.signal);
+    }
     wrap(sandbox) {
         return new Sandbox(this.client, sandbox);
     }

package/dist/errors.d.ts

@@ -26,3 +26,55 @@ export declare class MicroVMApiError extends Error {
         retryAfterMs?: number;
     });
 }
+/** HTTP 404: the sandbox, file, snapshot or other thing the call named does not exist (or is not yours). */
+export declare class MicroVMNotFoundError extends MicroVMApiError {
+}
+/** HTTP 409: the call clashes with what is there now, such as a sandbox name you already use. */
+export declare class MicroVMConflictError extends MicroVMApiError {
+}
+/**
+ * HTTP 503: the server has no room for the call right now or is shedding
+ * load. The SDK has already retried it; try again later.
+ */
+export declare class MicroVMCapacityError extends MicroVMApiError {
+}
+/** HTTP 408 or 504: the server, or a proxy in front of it, gave up waiting. */
+export declare class MicroVMTimeoutError extends MicroVMApiError {
+}
+/** HTTP 401 or 403: the token is missing, wrong or expired (401), or it may not do this (403). */
+export declare class MicroVMAuthError extends MicroVMApiError {
+}
+/** The most specific {@link MicroVMApiError} subclass for a status. */
+export declare function apiErrorFor(status: number, message: string, options?: {
+    code?: string;
+    retryAfterMs?: number;
+}): MicroVMApiError;
+/**
+ * The sandbox's agent (toolboxd) is older than an option this call needs. An
+ * older agent would silently ignore the option (an overwrite guard, an output
+ * cap), so the SDK refuses instead of sending it. Restart the sandbox, or
+ * re-create its Firecracker template, to get the current agent.
+ */
+export declare class MicroVMUnsupportedFeatureError extends Error {
+    /** The sandbox whose agent is too old. */
+    readonly sandboxID: string;
+    /** The features the agent did not list. */
+    readonly features: string[];
+    /** The agent's version when it reported one. */
+    readonly agentVersion: string;
+    /**
+     * Set (for example "wasm") when the sandbox's runtime cannot offer the
+     * features at all; a restart does not help there.
+     */
+    readonly runtime: string;
+    constructor(sandboxID: string, features: string[], agentVersion?: string, runtime?: string);
+}
+/**
+ * A download was larger than its `maxBytes`. Thrown before reading when the
+ * server states the size, otherwise as soon as more arrives.
+ */
+export declare class MicroVMFileTooLargeError extends Error {
+    readonly path: string;
+    readonly maxBytes: number;
+    constructor(path: string, maxBytes: number);
+}

package/dist/errors.js

@@ -29,3 +29,92 @@ export class MicroVMApiError extends Error {
         this.retryAfterMs = options.retryAfterMs;
     }
 }
+// The typed errors below extend MicroVMApiError, so code that catches
+// MicroVMApiError and reads `status` keeps working unchanged; new code can
+// test `instanceof` for the one case it handles instead of comparing numbers.
+// They keep `name` "MicroVMApiError": code that checks the name (often done
+// where two copies of the SDK make instanceof unreliable) keeps working too.
+/** HTTP 404: the sandbox, file, snapshot or other thing the call named does not exist (or is not yours). */
+export class MicroVMNotFoundError extends MicroVMApiError {
+}
+/** HTTP 409: the call clashes with what is there now, such as a sandbox name you already use. */
+export class MicroVMConflictError extends MicroVMApiError {
+}
+/**
+ * HTTP 503: the server has no room for the call right now or is shedding
+ * load. The SDK has already retried it; try again later.
+ */
+export class MicroVMCapacityError extends MicroVMApiError {
+}
+/** HTTP 408 or 504: the server, or a proxy in front of it, gave up waiting. */
+export class MicroVMTimeoutError extends MicroVMApiError {
+}
+/** HTTP 401 or 403: the token is missing, wrong or expired (401), or it may not do this (403). */
+export class MicroVMAuthError extends MicroVMApiError {
+}
+const API_ERROR_CLASSES = {
+    401: MicroVMAuthError,
+    403: MicroVMAuthError,
+    404: MicroVMNotFoundError,
+    408: MicroVMTimeoutError,
+    409: MicroVMConflictError,
+    503: MicroVMCapacityError,
+    504: MicroVMTimeoutError,
+};
+/** The most specific {@link MicroVMApiError} subclass for a status. */
+export function apiErrorFor(status, message, options = {}) {
+    const ErrorClass = API_ERROR_CLASSES[status] ?? MicroVMApiError;
+    return new ErrorClass(status, message, options);
+}
+/**
+ * The sandbox's agent (toolboxd) is older than an option this call needs. An
+ * older agent would silently ignore the option (an overwrite guard, an output
+ * cap), so the SDK refuses instead of sending it. Restart the sandbox, or
+ * re-create its Firecracker template, to get the current agent.
+ */
+export class MicroVMUnsupportedFeatureError extends Error {
+    /** The sandbox whose agent is too old. */
+    sandboxID;
+    /** The features the agent did not list. */
+    features;
+    /** The agent's version when it reported one. */
+    agentVersion;
+    /**
+     * Set (for example "wasm") when the sandbox's runtime cannot offer the
+     * features at all; a restart does not help there.
+     */
+    runtime;
+    constructor(sandboxID, features, agentVersion = "", runtime = "") {
+        const agent = agentVersion ? `toolboxd ${agentVersion}` : "an older toolboxd";
+        super(runtime
+            ? `sandbox ${sandboxID} is a ${runtimeDisplayName(runtime)} sandbox, which does not support ${features.join(", ")}`
+            : `sandbox ${sandboxID} runs ${agent}, which does not support ${features.join(", ")}; ` +
+                "restart the sandbox, or re-create its Firecracker template, to get the current agent");
+        this.name = "MicroVMUnsupportedFeatureError";
+        this.sandboxID = sandboxID;
+        this.features = features;
+        this.agentVersion = agentVersion;
+        this.runtime = runtime;
+    }
+}
+function runtimeDisplayName(runtime) {
+    if (runtime === "wasm")
+        return "WebAssembly";
+    if (runtime === "isolate")
+        return "V8 isolate";
+    return runtime;
+}
+/**
+ * A download was larger than its `maxBytes`. Thrown before reading when the
+ * server states the size, otherwise as soon as more arrives.
+ */
+export class MicroVMFileTooLargeError extends Error {
+    path;
+    maxBytes;
+    constructor(path, maxBytes) {
+        super(`${path} is larger than maxBytes (${maxBytes} bytes)`);
+        this.name = "MicroVMFileTooLargeError";
+        this.path = path;
+        this.maxBytes = maxBytes;
+    }
+}

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export { MicroVM } from "./MicroVM.js";
 export { Sandbox } from "./Sandbox.js";
 export { Image } from "./Image.js";
-export { MicroVMApiError } from "./errors.js";
-export type { MicroVMConfig, Tokens } from "./MicroVM.js";
+export { MicroVMApiError, MicroVMAuthError, MicroVMCapacityError, MicroVMConflictError, MicroVMFileTooLargeError, MicroVMNotFoundError, MicroVMTimeoutError, MicroVMUnsupportedFeatureError, } from "./errors.js";
+export { DEFAULT_LIST_LIMIT } from "./internal/client.js";
+export type { GetOrCreateResult, MicroVMConfig, Tokens } from "./MicroVM.js";
 export type { RetryConfig } from "./internal/client.js";
-export type { AddCustomDomainOptions, APIToken, APITokenList, CreateAPITokenOptions, CreatedAPIToken, WhoAmI, WhoAmIPrincipal, AuditEvent, AuditOptions, AuditPage, EgressProfile, EgressProfileList, EgressProfileOptions, EgressProfileRef, EgressInject, EgressRule, ListEgressProfilesOptions, NetworkLearned, NetworkLearnedEntry, NetworkPolicy, NetworkPolicyCheckOptions, NetworkPolicyCheckResult, NetworkPolicyOptions, BinaryLike, BuildImageOptions, BuildImagePushOptions, BuildImageResult, CloneGeneration, CreateOptions, CreateSessionOptions, CreateTemplateOptions, CreateWasmModuleOptions, CustomDomain, CustomDomainDNSRecords, CustomDomainStatus, DNSRecord, DNSRecordType, ExecRequest, ExecResult, ExecExitInfo, ExposedPort, ExposePortOptions, ExposeProtocol, ExposeResult, Failover, FailoverPolicy, GetOptions, HealthStatus, IngressTarget, IngressTargetSource, Lifecycle, ListOptions, MountSpec, MountSpecRedacted, MountType, PlatformVolumeMount, CreateSnapshotOptions, RegisterSnapshotOptions, ListSnapshotsOptions, SnapshotList, RegistryAuth, ResizeOptions, Sandbox as SandboxData, SandboxSnapshot, SandboxStatus, Session, SessionAttachHandle, SessionAttachOptions, SessionStatus, Template, TemplatePushState, TemplateStatus, WasmModule, WasmModuleStatus, PushWasmModuleOptions, PushWasmModuleResult, UpdateLifecycleOptions, } from "./types.js";
+export type { AddCustomDomainOptions, APIToken, APITokenList, CreateAPITokenOptions, CreatedAPIToken, CreateSandboxTokenOptions, RevokeSandboxTokensResult, SandboxToken, WhoAmI, WhoAmIPrincipal, AuditEvent, AuditOptions, AuditPage, EgressProfile, EgressProfileList, EgressProfileOptions, EgressProfileRef, IdentityOptions, IdentityRole, IdentityRoleList, IdentityRoleOptions, ListIdentityRolesOptions, SandboxIdentity, EgressInject, EgressRule, ListEgressProfilesOptions, WarmPool, WarmPoolOnImageChange, WarmPoolOptions, WarmPoolServerStatus, WarmPoolStatus, NetworkLearned, NetworkLearnedEntry, NetworkPolicy, NetworkPolicyCheckOptions, NetworkPolicyCheckResult, NetworkPolicyOptions, BinaryLike, BuildImageOptions, BuildImagePushOptions, CallOptions, BuildImageResult, CloneGeneration, CreateOptions, CreateSessionOptions, CreateTemplateOptions, CreateWasmModuleOptions, DestroyAllOptions, CustomDomain, CustomDomainDNSRecords, CustomDomainStatus, DNSRecord, DNSRecordType, ExecRequest, ExecResult, ExecExitInfo, ExposedPort, ExposePortOptions, ExposeProtocol, ExposeResult, ExposeVisibility, Failover, FailoverPolicy, FileEvent, FileEventType, FileWatchHandle, FileInfo, FileList, UploadFileOptions, DownloadFileOptions, FileMatch, ListFilesOptions, DeleteFileOptions, MakeDirOptions, MoveFileOptions, CopyFileOptions, PlacementRule, TeamQuota, TeamQuotaOptions, TeamQuotaUsage, GetOptions, HealthStatus, IngressTarget, IngressTargetSource, Lifecycle, ListOptions, MountSpec, MountSpecRedacted, MountType, PlatformVolumeMount, CreateSnapshotOptions, RegisterSnapshotOptions, ListSnapshotsOptions, SnapshotList, RegistryAuth, ResizeOptions, Sandbox as SandboxData, SandboxSnapshot, SandboxStatus, StatusReason, Session, SessionAttachHandle, SessionAttachOptions, SessionStatus, Template, TemplatePushState, TemplateStatus, WasmModule, WasmModuleStatus, PushWasmModuleOptions, PushWasmModuleResult, UpdateLifecycleOptions, WatchFilesOptions, } from "./types.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 export { MicroVM } from "./MicroVM.js";
 export { Sandbox } from "./Sandbox.js";
 export { Image } from "./Image.js";
-export { MicroVMApiError } from "./errors.js";
+export { MicroVMApiError, MicroVMAuthError, MicroVMCapacityError, MicroVMConflictError, MicroVMFileTooLargeError, MicroVMNotFoundError, MicroVMTimeoutError, MicroVMUnsupportedFeatureError, } from "./errors.js";
+export { DEFAULT_LIST_LIMIT } from "./internal/client.js";