@agen-ai/sandbox 0.0.0-stage → 0.4.4

package/dist/node/directories/types.js

@@ -0,0 +1,17 @@
+class SandboxDirectoryCleanupError extends Error {
+  constructor(primaryError, cleanupError, directory, owner, publishedDirectory) {
+    super("Directory transfer failed or its local filesystem cleanup remains owned.", { cause: primaryError });
+    this.primaryError = primaryError;
+    this.cleanupError = cleanupError;
+    this.directory = directory;
+    this.owner = owner;
+    this.publishedDirectory = publishedDirectory;
+    this.name = "SandboxDirectoryCleanupError";
+  }
+  retryCleanup() {
+    return this.owner.close();
+  }
+}
+export {
+  SandboxDirectoryCleanupError
+};

package/dist/node/hostPath.d.ts

@@ -0,0 +1,7 @@
+import type { BigIntStats } from 'node:fs';
+export declare function canonicalHostPath(input: unknown): string;
+export declare function verifyHostDirectory(path: string, signal?: AbortSignal): Promise<BigIntStats>;
+export declare function sameIdentity(left: BigIntStats, right: BigIntStats): boolean;
+export declare function verifyDirectoryIdentity(path: string, expected: BigIntStats): Promise<void>;
+export declare function verifyRegularIdentity(current: BigIntStats, expected: BigIntStats): void;
+//# sourceMappingURL=hostPath.d.ts.map

package/dist/node/hostPath.js

@@ -0,0 +1,37 @@
+import { lstat, realpath } from "node:fs/promises";
+import { isAbsolute, normalize } from "node:path";
+import { SandboxOperationError } from "../errors.js";
+import { invalidInput } from "../internal/data.js";
+function canonicalHostPath(input) {
+  if (typeof input !== "string" || input.includes("\0") || !isAbsolute(input) || normalize(input) !== input || input.length > 1 && input.endsWith("/")) invalidInput("Select an explicit canonical absolute host path");
+  return input;
+}
+async function verifyHostDirectory(path, signal) {
+  signal?.throwIfAborted();
+  const metadata = await lstat(path, { bigint: true });
+  signal?.throwIfAborted();
+  if (!metadata.isDirectory() || await realpath(path) !== path) invalidInput("Host root must be an existing canonical directory without symlink components");
+  signal?.throwIfAborted();
+  return metadata;
+}
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+async function verifyDirectoryIdentity(path, expected) {
+  const current = await lstat(path, { bigint: true });
+  if (!current.isDirectory() || !sameIdentity(current, expected)) {
+    throw new SandboxOperationError("input_limit", "Host directory identity changed during the transfer.");
+  }
+}
+function verifyRegularIdentity(current, expected) {
+  if (!current.isFile() || !sameIdentity(current, expected) || current.size !== expected.size || current.mtimeNs !== expected.mtimeNs || current.ctimeNs !== expected.ctimeNs) {
+    throw new SandboxOperationError("input_limit", "Host file identity, length or modification metadata changed during the transfer.");
+  }
+}
+export {
+  canonicalHostPath,
+  sameIdentity,
+  verifyDirectoryIdentity,
+  verifyHostDirectory,
+  verifyRegularIdentity
+};

package/dist/node/index.d.ts

@@ -0,0 +1,8 @@
+export { createSandboxSpillStore, SandboxSpillCleanupError } from './spill.js';
+export type { SandboxSpillStoreOptions } from './spill.js';
+export { parseSandboxSpillDirectory, verifySandboxSpillDirectory } from './spillDirectory.js';
+export { importSandboxDirectory } from './directories/import.js';
+export { exportSandboxDirectory } from './directories/export.js';
+export { SandboxDirectoryCleanupError } from './directories/types.js';
+export type { SandboxDirectoryImportOptions, SandboxDirectoryExportResult } from './directories/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/index.js

@@ -0,0 +1,14 @@
+import { createSandboxSpillStore, SandboxSpillCleanupError } from "./spill.js";
+import { parseSandboxSpillDirectory, verifySandboxSpillDirectory } from "./spillDirectory.js";
+import { importSandboxDirectory } from "./directories/import.js";
+import { exportSandboxDirectory } from "./directories/export.js";
+import { SandboxDirectoryCleanupError } from "./directories/types.js";
+export {
+  SandboxDirectoryCleanupError,
+  SandboxSpillCleanupError,
+  createSandboxSpillStore,
+  exportSandboxDirectory,
+  importSandboxDirectory,
+  parseSandboxSpillDirectory,
+  verifySandboxSpillDirectory
+};

package/dist/node/spill.d.ts

@@ -0,0 +1,14 @@
+import type { SandboxDriverSpillStore } from '../backend/spill.js';
+export interface SandboxSpillStoreOptions {
+    readonly directory: string;
+    readonly signal?: AbortSignal;
+}
+export declare class SandboxSpillCleanupError extends Error {
+    readonly primaryError: unknown;
+    readonly cleanupError: unknown;
+    readonly owner: SandboxDriverSpillStore;
+    constructor(primaryError: unknown, cleanupError: unknown, owner: SandboxDriverSpillStore);
+    retryCleanup(): Promise<void>;
+}
+export declare function createSandboxSpillStore(input: SandboxSpillStoreOptions): Promise<SandboxDriverSpillStore>;
+//# sourceMappingURL=spill.d.ts.map

package/dist/node/spill.js

@@ -0,0 +1,97 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { SandboxStateError } from "../errors.js";
+import { invalidInput } from "../internal/data.js";
+import { parseOperationOptions } from "../internal/operations.js";
+import { parseSandboxSpillDirectory, verifySandboxSpillDirectory } from "./spillDirectory.js";
+import { SpillFile } from "./spillFile.js";
+class SandboxSpillCleanupError extends Error {
+  constructor(primaryError, cleanupError, owner) {
+    super("Spill acquisition failed and its exact cleanup remains owned.", { cause: primaryError });
+    this.primaryError = primaryError;
+    this.cleanupError = cleanupError;
+    this.owner = owner;
+    this.name = "SandboxSpillCleanupError";
+  }
+  retryCleanup() {
+    return this.owner.close();
+  }
+}
+class SpillStore {
+  constructor(directory, signal) {
+    this.directory = directory;
+    this.signal = signal;
+  }
+  phase = "open";
+  files = /* @__PURE__ */ new Set();
+  acquiring;
+  closing;
+  createFile() {
+    this.admit();
+    if (this.acquiring || this.files.size === 4) return Promise.reject(new SandboxStateError("Spill store admits four files and one acquisition at a time."));
+    const path = join(this.directory, `agenai-metadata-${randomUUID()}`);
+    const file = new SpillFile(() => this.admit(), () => this.files.delete(file));
+    this.files.add(file);
+    const actual = (async () => {
+      try {
+        file.attach(await open(path, constants.O_CREAT | constants.O_EXCL | constants.O_RDWR | constants.O_NOFOLLOW, 384), path);
+        await file.unlink();
+        this.admit();
+        return file;
+      } catch (primaryError) {
+        try {
+          await file.close();
+        } catch (cleanupError) {
+          throw new SandboxSpillCleanupError(primaryError, cleanupError, this);
+        }
+        throw primaryError;
+      }
+    })().finally(() => {
+      if (this.acquiring === actual) this.acquiring = void 0;
+    });
+    this.acquiring = actual;
+    return actual;
+  }
+  close() {
+    if (this.phase === "closed") return Promise.resolve();
+    if (this.closing) return this.closing;
+    this.phase = "closing";
+    this.closing = (async () => {
+      await this.acquiring?.catch(() => {
+      });
+      const failures = [];
+      for (const file of this.files) {
+        try {
+          await file.close();
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      if (failures.length) throw new AggregateError(failures, "Spill store retains unresolved file cleanup.");
+      this.phase = "closed";
+    })().finally(() => {
+      this.closing = void 0;
+    });
+    return this.closing;
+  }
+  admit() {
+    if (this.phase !== "open") throw new SandboxStateError("Spill store admission is closed.");
+    this.signal?.throwIfAborted();
+  }
+}
+async function createSandboxSpillStore(input) {
+  if (!input || typeof input !== "object" || Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null || Reflect.ownKeys(input).some((key) => key !== "directory" && key !== "signal")) invalidInput("Spill options require only an explicit directory and optional signal");
+  const directory = Object.getOwnPropertyDescriptor(input, "directory");
+  const signal = Object.getOwnPropertyDescriptor(input, "signal");
+  if (!directory || !("value" in directory) || !directory.enumerable || signal && (!("value" in signal) || !signal.enumerable)) invalidInput("Spill options require enumerable data properties");
+  const root = parseSandboxSpillDirectory(directory.value);
+  const options = parseOperationOptions(signal ? { signal: signal.value } : void 0);
+  await verifySandboxSpillDirectory(root, options);
+  return new SpillStore(root, options.signal);
+}
+export {
+  SandboxSpillCleanupError,
+  createSandboxSpillStore
+};

package/dist/node/spillDirectory.d.ts

@@ -0,0 +1,4 @@
+import type { OperationOptions } from '../contracts.js';
+export declare function parseSandboxSpillDirectory(input: unknown): string;
+export declare function verifySandboxSpillDirectory(directory: string, input?: OperationOptions): Promise<void>;
+//# sourceMappingURL=spillDirectory.d.ts.map

package/dist/node/spillDirectory.js

@@ -0,0 +1,17 @@
+import { SandboxUnsupportedError } from "../errors.js";
+import { parseOperationOptions } from "../internal/operations.js";
+import { canonicalHostPath, verifyHostDirectory } from "./hostPath.js";
+function parseSandboxSpillDirectory(input) {
+  return canonicalHostPath(input);
+}
+async function verifySandboxSpillDirectory(directory, input) {
+  const root = parseSandboxSpillDirectory(directory);
+  const { signal } = parseOperationOptions(input);
+  signal?.throwIfAborted();
+  if (process.platform === "win32") throw new SandboxUnsupportedError("Metadata spill requires POSIX create-and-unlink semantics.");
+  await verifyHostDirectory(root, signal);
+}
+export {
+  parseSandboxSpillDirectory,
+  verifySandboxSpillDirectory
+};

package/dist/node/spillFile.d.ts

@@ -0,0 +1,24 @@
+import type { FileHandle } from 'node:fs/promises';
+import type { SandboxDriverSpillFile } from '../backend/spill.js';
+export declare class SpillFile implements SandboxDriverSpillFile {
+    private readonly admit;
+    private readonly released;
+    private file;
+    private path;
+    private phase;
+    private active;
+    private closing;
+    constructor(admit: () => void, released: () => void);
+    attach(file: FileHandle, path: string): void;
+    unlink(): Promise<void>;
+    read(buffer: Uint8Array, offset: number, length: number, position: number): Promise<Readonly<{
+        bytesRead: number;
+    }>>;
+    write(buffer: Uint8Array, offset: number, length: number, position: number): Promise<Readonly<{
+        bytesWritten: number;
+    }>>;
+    truncate(size: number): Promise<void>;
+    close(): Promise<void>;
+    private enter;
+}
+//# sourceMappingURL=spillFile.d.ts.map

package/dist/node/spillFile.js

@@ -0,0 +1,96 @@
+import { unlink } from "node:fs/promises";
+import { SandboxStateError } from "../errors.js";
+function address(value) {
+  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError("Spill file addresses must be nonnegative safe integers.");
+}
+function byteRange(buffer, offset, length, position) {
+  if (!(buffer instanceof Uint8Array)) throw new TypeError("Spill I/O requires a byte buffer.");
+  address(offset);
+  address(length);
+  address(position);
+  address(position + length);
+  if (offset + length > buffer.byteLength) throw new RangeError("Spill byte range exceeds its buffer.");
+}
+class SpillFile {
+  constructor(admit, released) {
+    this.admit = admit;
+    this.released = released;
+  }
+  file;
+  path;
+  phase = "open";
+  active;
+  closing;
+  attach(file, path) {
+    this.file = file;
+    this.path = path;
+  }
+  async unlink() {
+    if (!this.path) return;
+    await unlink(this.path);
+    this.path = void 0;
+  }
+  read(buffer, offset, length, position) {
+    byteRange(buffer, offset, length, position);
+    return this.enter(async (file) => {
+      const { bytesRead } = await file.read(buffer, offset, length, position);
+      return Object.freeze({ bytesRead });
+    });
+  }
+  write(buffer, offset, length, position) {
+    byteRange(buffer, offset, length, position);
+    return this.enter(async (file) => {
+      const { bytesWritten } = await file.write(buffer, offset, length, position);
+      return Object.freeze({ bytesWritten });
+    });
+  }
+  truncate(size) {
+    address(size);
+    return this.enter((file) => file.truncate(size));
+  }
+  close() {
+    if (this.phase === "closed") return Promise.resolve();
+    if (this.closing) return this.closing;
+    this.phase = "closing";
+    this.closing = (async () => {
+      await this.active?.catch(() => {
+      });
+      const failures = [];
+      try {
+        await this.unlink();
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") this.path = void 0;
+        else failures.push(error);
+      }
+      if (this.file) {
+        try {
+          await this.file.close();
+          this.file = void 0;
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      if (failures.length) throw new AggregateError(failures, "Native spill file cleanup remains owned.");
+      this.phase = "closed";
+      this.released();
+    })().finally(() => {
+      this.closing = void 0;
+    });
+    return this.closing;
+  }
+  enter(perform) {
+    this.admit();
+    if (this.phase !== "open" || !this.file || this.path || this.active) {
+      return Promise.reject(new SandboxStateError("Spill I/O requires an idle unlinked open file."));
+    }
+    const file = this.file;
+    const actual = perform(file).finally(() => {
+      if (this.active === actual) this.active = void 0;
+    });
+    this.active = actual;
+    return actual;
+  }
+}
+export {
+  SpillFile
+};

package/dist/policy/limits.d.ts

@@ -0,0 +1,31 @@
+export declare const SANDBOX_LIMITS: Readonly<{
+    maxTransferChunkBytes: number;
+    maxMetadataBatchBytes: number;
+    maxMetadataMergeFanIn: 32;
+    maxPathBytes: 1024;
+    maxPathSegments: 64;
+    maxPathSegmentBytes: 255;
+    maxArgs: 128;
+    maxEnvEntries: 128;
+    maxEnvValueBytes: number;
+    maxRecipeBytes: number;
+    maxBufferedOutputBytes: number;
+    maxBufferedInputBytes: number;
+    highWaterMarkBytes: number;
+    startupMs: 60000;
+    cleanupMs: 30000;
+    maxRecoveryBytes: number;
+    maxIdentityBytes: 256;
+    maxNamespaceBytes: 64;
+}>;
+export declare const SANDBOX_DEFAULT_TRANSFER_BUFFERS: Readonly<{
+    chunkBytes: number;
+    metadataBatchBytes: number;
+    metadataMergeFanIn: 8;
+}>;
+export declare const SANDBOX_DEFAULT_STREAM_LIMITS: Readonly<{
+    maxBufferedInputBytes: number;
+    maxBufferedOutputBytes: number;
+    highWaterMarkBytes: number;
+}>;
+//# sourceMappingURL=limits.d.ts.map

package/dist/policy/limits.js

@@ -0,0 +1,35 @@
+const SANDBOX_LIMITS = Object.freeze({
+  maxTransferChunkBytes: 64 * 1024,
+  maxMetadataBatchBytes: 4 * 1024 * 1024,
+  maxMetadataMergeFanIn: 32,
+  maxPathBytes: 1024,
+  maxPathSegments: 64,
+  maxPathSegmentBytes: 255,
+  maxArgs: 128,
+  maxEnvEntries: 128,
+  maxEnvValueBytes: 16 * 1024,
+  maxRecipeBytes: 256 * 1024,
+  maxBufferedOutputBytes: 8 * 1024 * 1024,
+  maxBufferedInputBytes: 8 * 1024 * 1024,
+  highWaterMarkBytes: 64 * 1024,
+  startupMs: 6e4,
+  cleanupMs: 3e4,
+  maxRecoveryBytes: 64 * 1024,
+  maxIdentityBytes: 256,
+  maxNamespaceBytes: 64
+});
+const SANDBOX_DEFAULT_TRANSFER_BUFFERS = Object.freeze({
+  chunkBytes: SANDBOX_LIMITS.maxTransferChunkBytes,
+  metadataBatchBytes: 64 * 1024,
+  metadataMergeFanIn: 8
+});
+const SANDBOX_DEFAULT_STREAM_LIMITS = Object.freeze({
+  maxBufferedInputBytes: SANDBOX_LIMITS.maxBufferedInputBytes,
+  maxBufferedOutputBytes: SANDBOX_LIMITS.maxBufferedOutputBytes,
+  highWaterMarkBytes: SANDBOX_LIMITS.highWaterMarkBytes
+});
+export {
+  SANDBOX_DEFAULT_STREAM_LIMITS,
+  SANDBOX_DEFAULT_TRANSFER_BUFFERS,
+  SANDBOX_LIMITS
+};

package/dist/policy/parse.d.ts

@@ -0,0 +1,11 @@
+import type { SandboxEffectivePolicy, SandboxId, SandboxNamespace, SandboxPolicy, SandboxProcessId, SandboxRequest, SandboxSupport } from './types.js';
+export declare function parseSandboxNamespace(input: unknown): SandboxNamespace;
+export declare function parseSandboxId(input: unknown): SandboxId;
+export declare function parseSandboxProcessId(input: unknown): SandboxProcessId;
+export declare function parseSandboxPolicy(input: unknown): SandboxPolicy;
+export declare function parseSandboxRequest(input: unknown): SandboxRequest;
+export declare function parseSandboxSupport(input: unknown): SandboxSupport;
+export declare function parseSandboxEffectivePolicy(input: unknown): SandboxEffectivePolicy;
+export declare function assertSandboxRequestSupported(request: SandboxRequest, support: SandboxSupport): void;
+export declare function assertSandboxEffectivePolicy(request: SandboxRequest, effective: SandboxEffectivePolicy): void;
+//# sourceMappingURL=parse.d.ts.map

package/dist/policy/parse.js

@@ -0,0 +1,47 @@
+import { SandboxUnsupportedError } from "../errors.js";
+import { parseData } from "../internal/parse.js";
+import { effectiveSchema, namespaceSchema, policySchema, processIdSchema, requestSchema, sandboxIdSchema, supportSchema } from "./schemas.js";
+function parseSandboxNamespace(input) {
+  return parseData(namespaceSchema, input);
+}
+function parseSandboxId(input) {
+  return parseData(sandboxIdSchema, input);
+}
+function parseSandboxProcessId(input) {
+  return parseData(processIdSchema, input);
+}
+function parseSandboxPolicy(input) {
+  return parseData(policySchema, input);
+}
+function parseSandboxRequest(input) {
+  return parseData(requestSchema, input);
+}
+function parseSandboxSupport(input) {
+  return parseData(supportSchema, input);
+}
+function parseSandboxEffectivePolicy(input) {
+  return parseData(effectiveSchema, input);
+}
+function assertSandboxRequestSupported(request, support) {
+  if (!support.networkModes.includes(request.policy.network.kind)) throw new SandboxUnsupportedError(`Backend does not support ${request.policy.network.kind} networking`);
+  if (request.policy.workspaceDiskQuota.kind === "required" && !support.workspaceDiskQuota) {
+    throw new SandboxUnsupportedError("Backend does not support a required allocated-block workspace disk quota");
+  }
+}
+function assertSandboxEffectivePolicy(request, effective) {
+  const desired = request.policy;
+  if (effective.resources.cpus !== desired.resources.cpus || effective.resources.memoryBytes !== desired.resources.memoryBytes || effective.resources.pids !== desired.resources.pids || effective.temporaryStorage.homeBytes !== desired.temporaryStorage.homeBytes || effective.temporaryStorage.tempBytes !== desired.temporaryStorage.tempBytes || effective.network.kind !== desired.network.kind || effective.workspaceDiskQuota.kind !== desired.workspaceDiskQuota.kind) {
+    throw new SandboxUnsupportedError("Backend effective policy does not match the requested policy");
+  }
+}
+export {
+  assertSandboxEffectivePolicy,
+  assertSandboxRequestSupported,
+  parseSandboxEffectivePolicy,
+  parseSandboxId,
+  parseSandboxNamespace,
+  parseSandboxPolicy,
+  parseSandboxProcessId,
+  parseSandboxRequest,
+  parseSandboxSupport
+};

package/dist/policy/schemas.d.ts

@@ -0,0 +1,148 @@
+import { z } from 'zod/v4';
+import type { SandboxId, SandboxNamespace, SandboxProcessId } from './types.js';
+export declare const identitySchema: z.ZodString;
+export declare const namespaceSchema: z.ZodCustom<SandboxNamespace, SandboxNamespace>;
+export declare const sandboxIdSchema: z.ZodCustom<SandboxId, SandboxId>;
+export declare const processIdSchema: z.ZodCustom<SandboxProcessId, SandboxProcessId>;
+export declare const transferBuffersSchema: z.ZodObject<{
+    chunkBytes: z.ZodNumber;
+    metadataBatchBytes: z.ZodNumber;
+    metadataMergeFanIn: z.ZodNumber;
+}, z.core.$strict>;
+export declare const streamLimitsSchema: z.ZodObject<{
+    maxStdinBytes: z.ZodOptional<z.ZodNumber>;
+    maxOutputBytes: z.ZodOptional<z.ZodNumber>;
+    maxBufferedInputBytes: z.ZodNumber;
+    maxBufferedOutputBytes: z.ZodNumber;
+    highWaterMarkBytes: z.ZodNumber;
+}, z.core.$strict>;
+export declare const policySchema: z.ZodObject<{
+    resources: z.ZodObject<{
+        cpus: z.ZodNumber;
+        memoryBytes: z.ZodNumber;
+        pids: z.ZodNumber;
+    }, z.core.$strict>;
+    temporaryStorage: z.ZodObject<{
+        homeBytes: z.ZodNumber;
+        tempBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    network: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"isolated">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"outbound">;
+    }, z.core.$strict>], "kind">;
+    workspaceDiskQuota: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"not_requested">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"required">;
+        bytes: z.ZodNumber;
+        accounting: z.ZodLiteral<"allocated_blocks">;
+    }, z.core.$strict>], "kind">>;
+    execution: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"until_stopped">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"deadline">;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "kind">>;
+    deadlines: z.ZodObject<{
+        startupMs: z.ZodNumber;
+        cleanupMs: z.ZodNumber;
+    }, z.core.$strict>;
+    transfers: z.ZodObject<{
+        chunkBytes: z.ZodNumber;
+        metadataBatchBytes: z.ZodNumber;
+        metadataMergeFanIn: z.ZodNumber;
+    }, z.core.$strict>;
+    streams: z.ZodObject<{
+        maxStdinBytes: z.ZodOptional<z.ZodNumber>;
+        maxOutputBytes: z.ZodOptional<z.ZodNumber>;
+        maxBufferedInputBytes: z.ZodNumber;
+        maxBufferedOutputBytes: z.ZodNumber;
+        highWaterMarkBytes: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const requestSchema: z.ZodObject<{
+    policy: z.ZodObject<{
+        resources: z.ZodObject<{
+            cpus: z.ZodNumber;
+            memoryBytes: z.ZodNumber;
+            pids: z.ZodNumber;
+        }, z.core.$strict>;
+        temporaryStorage: z.ZodObject<{
+            homeBytes: z.ZodNumber;
+            tempBytes: z.ZodNumber;
+        }, z.core.$strict>;
+        network: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"isolated">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"outbound">;
+        }, z.core.$strict>], "kind">;
+        workspaceDiskQuota: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"not_requested">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"required">;
+            bytes: z.ZodNumber;
+            accounting: z.ZodLiteral<"allocated_blocks">;
+        }, z.core.$strict>], "kind">>;
+        execution: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"until_stopped">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"deadline">;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>], "kind">>;
+        deadlines: z.ZodObject<{
+            startupMs: z.ZodNumber;
+            cleanupMs: z.ZodNumber;
+        }, z.core.$strict>;
+        transfers: z.ZodObject<{
+            chunkBytes: z.ZodNumber;
+            metadataBatchBytes: z.ZodNumber;
+            metadataMergeFanIn: z.ZodNumber;
+        }, z.core.$strict>;
+        streams: z.ZodObject<{
+            maxStdinBytes: z.ZodOptional<z.ZodNumber>;
+            maxOutputBytes: z.ZodOptional<z.ZodNumber>;
+            maxBufferedInputBytes: z.ZodNumber;
+            maxBufferedOutputBytes: z.ZodNumber;
+            highWaterMarkBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const supportSchema: z.ZodObject<{
+    backendId: z.ZodString;
+    backendRevision: z.ZodString;
+    networkModes: z.ZodArray<z.ZodEnum<{
+        isolated: "isolated";
+        outbound: "outbound";
+    }>>;
+    workspaceDiskQuota: z.ZodLiteral<false>;
+    networkAllowlist: z.ZodLiteral<false>;
+    independentProcessTermination: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export declare const effectiveSchema: z.ZodObject<{
+    backendIdentity: z.ZodString;
+    isolation: z.ZodEnum<{
+        container: "container";
+        virtual_machine: "virtual_machine";
+    }>;
+    resources: z.ZodObject<{
+        cpus: z.ZodNumber;
+        memoryBytes: z.ZodNumber;
+        pids: z.ZodNumber;
+    }, z.core.$strict>;
+    temporaryStorage: z.ZodObject<{
+        homeBytes: z.ZodNumber;
+        tempBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    network: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"isolated">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"outbound">;
+    }, z.core.$strict>], "kind">;
+    nonRoot: z.ZodLiteral<true>;
+    readOnlyRoot: z.ZodLiteral<true>;
+    workspaceDiskQuota: z.ZodObject<{
+        kind: z.ZodLiteral<"not_requested">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+//# sourceMappingURL=schemas.d.ts.map