@effect-uai/core 0.12.0 → 0.13.0

package/dist/sandbox/Sandbox.d.mts

@@ -1,8 +1,5 @@
-import { a as SandboxError } from "../SandboxError-CIrVDOMV.mjs";
+import { a as SandboxError } from "../SandboxError-BN8b28Bh.mjs";
 import { Brand, Context, Data, Duration, Effect, Redacted, Scope, Stream } from "effect";
-import * as _$effect_Unify0 from "effect/Unify";
-
-//#region src/sandbox/Sandbox.d.ts
 declare namespace Sandbox_d_exports {
   export { BoundSecret, CommonCreateRequest, CommonExecRequest, CommonSpawnRequest, ExecEvent, ExecResult, FileEntry, FileEntryKind, ImageRef, NetworkPolicy, ProcessHandle, Sandbox, SandboxCustomImage, SandboxFilesystem, SandboxHostnameAllowlist, SandboxId, SandboxInstance, SandboxKernelSession, SandboxPauseResume, SandboxPortExposure, SandboxPortsApi, SandboxPty, SandboxRef, SandboxSecretInjection, SandboxService, SandboxSnapshots, SandboxSnapshotsApi, SandboxVolumes, SandboxVolumesApi, SnapshotId, VolumeId, VolumeMount, attach, create, createVolume, destroy, destroySnapshot, destroyVolume, exposePort, list, listSnapshots, listVolumes, snapshot };
 }
@@ -58,23 +55,13 @@ type ImageRef = Data.TaggedEnum<{
   };
 }>;
 declare const ImageRef: {
-  readonly Default: Data.TaggedEnum.ConstructorFrom<{
+  readonly $is: <Tag extends "Default" | "Dockerfile" | "Registry" | "Snapshot">(tag: Tag) => (u: unknown) => u is Extract<{
     readonly _tag: "Default";
-  }, "_tag">;
-  readonly Registry: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Registry";
-    readonly ref: string;
-  }, "_tag">;
-  readonly Snapshot: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Snapshot";
-    readonly id: SnapshotId;
-  }, "_tag">;
-  readonly Dockerfile: Data.TaggedEnum.ConstructorFrom<{
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
     readonly _tag: "Dockerfile";
     readonly contents: string;
-  }, "_tag">;
-  readonly $is: <Tag extends "Default" | "Registry" | "Snapshot" | "Dockerfile">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Default";
   }, {
     readonly _tag: Tag;
   }> | Extract<{
@@ -87,70 +74,74 @@ declare const ImageRef: {
     readonly id: SnapshotId;
   }, {
     readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Dockerfile";
-    readonly contents: string;
-  }, {
-    readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends {
-      readonly Default: (args: {
-        readonly _tag: "Default";
-      }) => any;
-      readonly Registry: (args: {
-        readonly _tag: "Registry";
-        readonly ref: string;
-      }) => any;
-      readonly Snapshot: (args: {
-        readonly _tag: "Snapshot";
-        readonly id: SnapshotId;
-      }) => any;
-      readonly Dockerfile: (args: {
-        readonly _tag: "Dockerfile";
-        readonly contents: string;
-      }) => any;
-    }>(cases: Cases): (value: {
+    <Cases extends { readonly [Tag in "Default" | "Dockerfile" | "Registry" | "Snapshot"]: (args: Extract<{
       readonly _tag: "Default";
+    } | {
+      readonly _tag: "Dockerfile";
+      readonly contents: string;
     } | {
       readonly _tag: "Registry";
       readonly ref: string;
     } | {
       readonly _tag: "Snapshot";
       readonly id: SnapshotId;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Default";
     } | {
       readonly _tag: "Dockerfile";
       readonly contents: string;
-    }) => _$effect_Unify0.Unify<ReturnType<Cases["Default" | "Registry" | "Snapshot" | "Dockerfile"]>>;
-    <Cases extends {
-      readonly Default: (args: {
-        readonly _tag: "Default";
-      }) => any;
-      readonly Registry: (args: {
-        readonly _tag: "Registry";
-        readonly ref: string;
-      }) => any;
-      readonly Snapshot: (args: {
-        readonly _tag: "Snapshot";
-        readonly id: SnapshotId;
-      }) => any;
-      readonly Dockerfile: (args: {
-        readonly _tag: "Dockerfile";
-        readonly contents: string;
-      }) => any;
-    }>(value: {
+    } | {
+      readonly _tag: "Registry";
+      readonly ref: string;
+    } | {
+      readonly _tag: "Snapshot";
+      readonly id: SnapshotId;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Default" | "Dockerfile" | "Registry" | "Snapshot"]>>;
+    <Cases extends { readonly [Tag in "Default" | "Dockerfile" | "Registry" | "Snapshot"]: (args: Extract<{
       readonly _tag: "Default";
+    } | {
+      readonly _tag: "Dockerfile";
+      readonly contents: string;
     } | {
       readonly _tag: "Registry";
       readonly ref: string;
     } | {
       readonly _tag: "Snapshot";
       readonly id: SnapshotId;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Default";
     } | {
       readonly _tag: "Dockerfile";
       readonly contents: string;
-    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Default" | "Registry" | "Snapshot" | "Dockerfile"]>>;
+    } | {
+      readonly _tag: "Registry";
+      readonly ref: string;
+    } | {
+      readonly _tag: "Snapshot";
+      readonly id: SnapshotId;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Default" | "Dockerfile" | "Registry" | "Snapshot"]>>;
   };
+  readonly Default: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Default";
+  }, "_tag">;
+  readonly Dockerfile: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Dockerfile";
+    readonly contents: string;
+  }, "_tag">;
+  readonly Registry: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Registry";
+    readonly ref: string;
+  }, "_tag">;
+  readonly Snapshot: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Snapshot";
+    readonly id: SnapshotId;
+  }, "_tag">;
 };
 /**
  * Outbound network policy for a sandbox.
@@ -173,19 +164,10 @@ type NetworkPolicy = Data.TaggedEnum<{
   };
 }>;
 declare const NetworkPolicy: {
-  readonly Open: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Open";
-  }, "_tag">;
-  readonly Blocked: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Blocked";
-  }, "_tag">;
-  readonly Allowlist: Data.TaggedEnum.ConstructorFrom<{
+  readonly $is: <Tag extends "Allowlist" | "Blocked" | "Open">(tag: Tag) => (u: unknown) => u is Extract<{
     readonly _tag: "Allowlist";
     readonly hosts?: ReadonlyArray<string>;
     readonly cidrs?: ReadonlyArray<string>;
-  }, "_tag">;
-  readonly $is: <Tag extends "Open" | "Blocked" | "Allowlist">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Open";
   }, {
     readonly _tag: Tag;
   }> | Extract<{
@@ -193,56 +175,61 @@ declare const NetworkPolicy: {
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Allowlist";
-    readonly hosts?: ReadonlyArray<string>;
-    readonly cidrs?: ReadonlyArray<string>;
+    readonly _tag: "Open";
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends {
-      readonly Open: (args: {
-        readonly _tag: "Open";
-      }) => any;
-      readonly Blocked: (args: {
-        readonly _tag: "Blocked";
-      }) => any;
-      readonly Allowlist: (args: {
-        readonly _tag: "Allowlist";
-        readonly hosts?: ReadonlyArray<string>;
-        readonly cidrs?: ReadonlyArray<string>;
-      }) => any;
-    }>(cases: Cases): (value: {
-      readonly _tag: "Open";
+    <Cases extends { readonly [Tag in "Allowlist" | "Blocked" | "Open"]: (args: Extract<{
+      readonly _tag: "Allowlist";
+      readonly hosts?: ReadonlyArray<string>;
+      readonly cidrs?: ReadonlyArray<string>;
     } | {
       readonly _tag: "Blocked";
     } | {
+      readonly _tag: "Open";
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
       readonly _tag: "Allowlist";
       readonly hosts?: ReadonlyArray<string>;
       readonly cidrs?: ReadonlyArray<string>;
-    }) => _$effect_Unify0.Unify<ReturnType<Cases["Open" | "Blocked" | "Allowlist"]>>;
-    <Cases extends {
-      readonly Open: (args: {
-        readonly _tag: "Open";
-      }) => any;
-      readonly Blocked: (args: {
-        readonly _tag: "Blocked";
-      }) => any;
-      readonly Allowlist: (args: {
-        readonly _tag: "Allowlist";
-        readonly hosts?: ReadonlyArray<string>;
-        readonly cidrs?: ReadonlyArray<string>;
-      }) => any;
-    }>(value: {
+    } | {
+      readonly _tag: "Blocked";
+    } | {
       readonly _tag: "Open";
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Allowlist" | "Blocked" | "Open"]>>;
+    <Cases extends { readonly [Tag in "Allowlist" | "Blocked" | "Open"]: (args: Extract<{
+      readonly _tag: "Allowlist";
+      readonly hosts?: ReadonlyArray<string>;
+      readonly cidrs?: ReadonlyArray<string>;
     } | {
       readonly _tag: "Blocked";
     } | {
+      readonly _tag: "Open";
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
       readonly _tag: "Allowlist";
       readonly hosts?: ReadonlyArray<string>;
       readonly cidrs?: ReadonlyArray<string>;
-    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Open" | "Blocked" | "Allowlist"]>>;
+    } | {
+      readonly _tag: "Blocked";
+    } | {
+      readonly _tag: "Open";
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Allowlist" | "Blocked" | "Open"]>>;
   };
+  readonly Allowlist: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Allowlist";
+    readonly hosts?: ReadonlyArray<string>;
+    readonly cidrs?: ReadonlyArray<string>;
+  }, "_tag">;
+  readonly Blocked: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Blocked";
+  }, "_tag">;
+  readonly Open: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Open";
+  }, "_tag">;
 };
 /**
  * A secret bound to a sandbox at create time. The code inside the
@@ -284,7 +271,8 @@ type VolumeMount = {
  * footgun we're avoiding.
  */
 type CommonCreateRequest = {
-  /** Image / snapshot to boot from. Omit for the provider's default. */readonly image?: ImageRef;
+  /** Image / snapshot to boot from. Omit for the provider's default. */
+  readonly image?: ImageRef;
   /**
    * Idle / hard timeout. Accepts a number (millis), a string like
    * `"30 seconds"`, or a `Duration`. Providers default differently.
@@ -294,7 +282,8 @@ type CommonCreateRequest = {
    * Env vars exposed to the sandbox. NOT for secrets you want hidden
    * from the running code — use {@link BoundSecret} instead.
    */
-  readonly env?: Readonly<Record<string, string>>; /** Outbound network policy. */
+  readonly env?: Readonly<Record<string, string>>;
+  /** Outbound network policy. */
   readonly network?: NetworkPolicy;
   /**
    * Bound secrets — code inside the sandbox sees a placeholder; the
@@ -364,22 +353,10 @@ type ExecEvent = Data.TaggedEnum<{
   };
 }>;
 declare const ExecEvent: {
-  readonly Stdout: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Stdout";
-    readonly chunk: Uint8Array;
-  }, "_tag">;
-  readonly Stderr: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Stderr";
-    readonly chunk: Uint8Array;
-  }, "_tag">;
-  readonly Complete: Data.TaggedEnum.ConstructorFrom<{
+  readonly $is: <Tag extends "Complete" | "Stderr" | "Stdout">(tag: Tag) => (u: unknown) => u is Extract<{
     readonly _tag: "Complete";
     readonly exitCode: number;
     readonly durationMs: number;
-  }, "_tag">;
-  readonly $is: <Tag extends "Stdout" | "Stderr" | "Complete">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Stdout";
-    readonly chunk: Uint8Array;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
@@ -388,64 +365,72 @@ declare const ExecEvent: {
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Complete";
-    readonly exitCode: number;
-    readonly durationMs: number;
+    readonly _tag: "Stdout";
+    readonly chunk: Uint8Array;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends {
-      readonly Stdout: (args: {
-        readonly _tag: "Stdout";
-        readonly chunk: Uint8Array;
-      }) => any;
-      readonly Stderr: (args: {
-        readonly _tag: "Stderr";
-        readonly chunk: Uint8Array;
-      }) => any;
-      readonly Complete: (args: {
-        readonly _tag: "Complete";
-        readonly exitCode: number;
-        readonly durationMs: number;
-      }) => any;
-    }>(cases: Cases): (value: {
-      readonly _tag: "Stdout";
-      readonly chunk: Uint8Array;
+    <Cases extends { readonly [Tag in "Complete" | "Stderr" | "Stdout"]: (args: Extract<{
+      readonly _tag: "Complete";
+      readonly exitCode: number;
+      readonly durationMs: number;
     } | {
       readonly _tag: "Stderr";
       readonly chunk: Uint8Array;
     } | {
+      readonly _tag: "Stdout";
+      readonly chunk: Uint8Array;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
       readonly _tag: "Complete";
       readonly exitCode: number;
       readonly durationMs: number;
-    }) => _$effect_Unify0.Unify<ReturnType<Cases["Stdout" | "Stderr" | "Complete"]>>;
-    <Cases extends {
-      readonly Stdout: (args: {
-        readonly _tag: "Stdout";
-        readonly chunk: Uint8Array;
-      }) => any;
-      readonly Stderr: (args: {
-        readonly _tag: "Stderr";
-        readonly chunk: Uint8Array;
-      }) => any;
-      readonly Complete: (args: {
-        readonly _tag: "Complete";
-        readonly exitCode: number;
-        readonly durationMs: number;
-      }) => any;
-    }>(value: {
+    } | {
+      readonly _tag: "Stderr";
+      readonly chunk: Uint8Array;
+    } | {
       readonly _tag: "Stdout";
       readonly chunk: Uint8Array;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Complete" | "Stderr" | "Stdout"]>>;
+    <Cases extends { readonly [Tag in "Complete" | "Stderr" | "Stdout"]: (args: Extract<{
+      readonly _tag: "Complete";
+      readonly exitCode: number;
+      readonly durationMs: number;
     } | {
       readonly _tag: "Stderr";
       readonly chunk: Uint8Array;
     } | {
+      readonly _tag: "Stdout";
+      readonly chunk: Uint8Array;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
       readonly _tag: "Complete";
       readonly exitCode: number;
       readonly durationMs: number;
-    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["Stdout" | "Stderr" | "Complete"]>>;
+    } | {
+      readonly _tag: "Stderr";
+      readonly chunk: Uint8Array;
+    } | {
+      readonly _tag: "Stdout";
+      readonly chunk: Uint8Array;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Complete" | "Stderr" | "Stdout"]>>;
   };
+  readonly Complete: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Complete";
+    readonly exitCode: number;
+    readonly durationMs: number;
+  }, "_tag">;
+  readonly Stderr: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Stderr";
+    readonly chunk: Uint8Array;
+  }, "_tag">;
+  readonly Stdout: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Stdout";
+    readonly chunk: Uint8Array;
+  }, "_tag">;
 };
 type FileEntryKind = "file" | "directory" | "symlink" | "other";
 type FileEntry = {
@@ -565,9 +550,12 @@ type SandboxService = {
    * Escape hatch for destroying a sandbox from outside its owning
    * scope. Most callers should let the scope finalizer handle this.
    */
-  readonly destroy: (id: SandboxId) => Effect.Effect<void, SandboxError>; /** Snapshot management. Capability-gated on {@link SandboxSnapshots}. */
-  readonly snapshots: SandboxSnapshotsApi; /** Volume management. Capability-gated on {@link SandboxVolumes}. */
-  readonly volumes: SandboxVolumesApi; /** Port exposure. Capability-gated on {@link SandboxPortExposure}. */
+  readonly destroy: (id: SandboxId) => Effect.Effect<void, SandboxError>;
+  /** Snapshot management. Capability-gated on {@link SandboxSnapshots}. */
+  readonly snapshots: SandboxSnapshotsApi;
+  /** Volume management. Capability-gated on {@link SandboxVolumes}. */
+  readonly volumes: SandboxVolumesApi;
+  /** Port exposure. Capability-gated on {@link SandboxPortExposure}. */
   readonly ports: SandboxPortsApi;
 };
 declare const Sandbox_base: Context.ServiceClass<Sandbox, "@betalyra/effect-uai/Sandbox", SandboxService>;

package/dist/sandbox/Sandbox.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Sandbox.d.mts","names":[],"sources":["../../src/sandbox/Sandbox.ts"],"mappings":"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"}
+{"version":3,"file":"Sandbox.d.mts","names":[],"sources":["../../src/sandbox/Sandbox.ts"],"mappings":"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"}

package/dist/sandbox/Sandbox.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { Brand, Context, Data, Effect } from "effect";
 //#region src/sandbox/Sandbox.ts
 var Sandbox_exports = /* @__PURE__ */ __exportAll({

package/dist/sandbox/Sandbox.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Sandbox.mjs","names":[],"sources":["../../src/sandbox/Sandbox.ts"],"sourcesContent":["import { Brand, Context, Data, type Duration, Effect, Redacted, Scope, Stream } from \"effect\"\nimport type * as SandboxError from \"./SandboxError.js\"\n\n// ---------------------------------------------------------------------------\n// Identity\n// ---------------------------------------------------------------------------\n\n/**\n * Sandbox identifier. Branded `string` so providers don't accidentally\n * accept a raw user-supplied id. Each provider mints these per its own\n * naming scheme (uuid for E2B/Vercel, user-supplied name for\n * Microsandbox/Modal, …); the core code treats them opaquely.\n *\n * Mint via the value-level `SandboxId(...)` smart constructor instead\n * of `as SandboxId` casts.\n */\nexport type SandboxId = Brand.Branded<string, \"SandboxId\">\nexport const SandboxId = Brand.nominal<SandboxId>()\n\n/**\n * Reference returned by `list`. Carries just enough to call `attach` —\n * provider-specific metadata (createdAt, region, tags, …) lives on the\n * narrowed per-provider ref.\n */\nexport type SandboxRef = {\n  readonly id: SandboxId\n  readonly name?: string\n}\n\nexport type VolumeId = Brand.Branded<string, \"VolumeId\">\nexport const VolumeId = Brand.nominal<VolumeId>()\n\nexport type SnapshotId = Brand.Branded<string, \"SnapshotId\">\nexport const SnapshotId = Brand.nominal<SnapshotId>()\n\n// ---------------------------------------------------------------------------\n// Image / runtime selection\n// ---------------------------------------------------------------------------\n\n/**\n * What runtime / filesystem to boot the sandbox from.\n *\n * - `Default` — provider picks its house image (Vercel: Amazon Linux\n *   2023; Microsandbox: requires user image but a builder default may\n *   apply, …). Use when you don't care what's pre-installed.\n * - `Registry` — an OCI image reference. Supported by every provider\n *   except those with a fixed base (Vercel ignores this and the\n *   request-schema rejects at decode).\n * - `Snapshot` — restore from a captured state. Gated by\n *   {@link SandboxSnapshots} at the call site — the marker is provided\n *   by adapters whose provider supports snapshot-as-image.\n * - `Dockerfile` — provider builds a custom image from a Dockerfile.\n *   Gated by {@link SandboxCustomImage}.\n */\nexport type ImageRef = Data.TaggedEnum<{\n  Default: {}\n  Registry: { readonly ref: string }\n  Snapshot: { readonly id: SnapshotId }\n  Dockerfile: { readonly contents: string }\n}>\n\nexport const ImageRef = Data.taggedEnum<ImageRef>()\n\n// ---------------------------------------------------------------------------\n// Network policy + secrets\n// ---------------------------------------------------------------------------\n\n/**\n * Outbound network policy for a sandbox.\n *\n * - `Open` — no egress restriction. The provider's defaults apply\n *   (e.g. Microsandbox's \"public-only\" still blocks private ranges).\n * - `Blocked` — fully airgapped, no outbound connectivity at all.\n * - `Allowlist` — only the listed hosts / CIDRs may be reached.\n *\n * Providers vary in what they honour: hostname-allowlist requires\n * {@link SandboxHostnameAllowlist}; CIDR-only providers ignore `hosts`\n * and the adapter rejects at decode if `hosts` is non-empty.\n */\nexport type NetworkPolicy = Data.TaggedEnum<{\n  Open: {}\n  Blocked: {}\n  Allowlist: {\n    readonly hosts?: ReadonlyArray<string>\n    readonly cidrs?: ReadonlyArray<string>\n  }\n}>\n\nexport const NetworkPolicy = Data.taggedEnum<NetworkPolicy>()\n\n/**\n * A secret bound to a sandbox at create time. The code inside the\n * sandbox sees only a placeholder (`$MSB_<NAME>` for Microsandbox,\n * `{name}` for Vercel header-injection, etc.); the real `value` lives\n * on the provider's proxy and is substituted on outbound HTTPS to\n * `hosts`.\n *\n * Requires the {@link SandboxSecretInjection} capability marker —\n * provider Layers without proxy-layer secret rewriting do not ship the\n * marker and consumer code fails at `Effect.provide` with a type\n * error.\n *\n * `header` is the request header to inject (default\n * `\"Authorization: Bearer <value>\"`). Providers that do not let\n * callers pick the header (Microsandbox's `secretEnv` shorthand)\n * silently ignore this field; providers that require an explicit\n * header (Vercel's `transform.headers`) fail at decode if it's absent.\n */\nexport type BoundSecret = {\n  readonly name: string\n  readonly value: Redacted.Redacted<string>\n  readonly hosts: ReadonlyArray<string>\n  readonly header?: string\n}\n\n// ---------------------------------------------------------------------------\n// Volumes (capability-gated on `SandboxVolumes`)\n// ---------------------------------------------------------------------------\n\nexport type VolumeMount = {\n  readonly id: VolumeId\n  readonly mountPath: string\n  readonly readonly?: boolean\n}\n\n// ---------------------------------------------------------------------------\n// Create / exec request shapes\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider create request. Provider-specific knobs (region,\n * cpus, memory, template id, …) live on each provider's narrowed\n * request type which extends this.\n *\n * Fields a provider can't honour fail at **decode time** (per the\n * per-provider request schema), not silently at runtime. The\n * ComputeSDK anti-pattern of \"drop unsupported fields\" is the\n * footgun we're avoiding.\n */\nexport type CommonCreateRequest = {\n  /** Image / snapshot to boot from. Omit for the provider's default. */\n  readonly image?: ImageRef\n  /**\n   * Idle / hard timeout. Accepts a number (millis), a string like\n   * `\"30 seconds\"`, or a `Duration`. Providers default differently.\n   */\n  readonly timeout?: Duration.Input\n  /**\n   * Env vars exposed to the sandbox. NOT for secrets you want hidden\n   * from the running code — use {@link BoundSecret} instead.\n   */\n  readonly env?: Readonly<Record<string, string>>\n  /** Outbound network policy. */\n  readonly network?: NetworkPolicy\n  /**\n   * Bound secrets — code inside the sandbox sees a placeholder; the\n   * proxy substitutes the real value on outbound HTTPS to listed hosts.\n   * Capability-gated on {@link SandboxSecretInjection}.\n   */\n  readonly secrets?: ReadonlyArray<BoundSecret>\n  /**\n   * Persistent volumes to mount. Volumes are created via\n   * `Sandbox.volumes.create` and survive sandbox lifetime.\n   * Capability-gated on {@link SandboxVolumes}.\n   */\n  readonly volumes?: ReadonlyArray<VolumeMount>\n}\n\n/**\n * Cross-provider exec request. Background / long-running processes\n * use `spawn` instead of `exec`; the semantics differ enough that\n * overloading `exec` with a `detached` flag was rejected during\n * design.\n */\nexport type CommonExecRequest = {\n  /**\n   * Argv-style command. Pass a string for \"run this through the\n   * shell\" semantics (provider-dependent — most use `sh -c`); pass\n   * an array for direct argv with no shell parsing.\n   */\n  readonly cmd: string | ReadonlyArray<string>\n  readonly cwd?: string\n  readonly env?: Readonly<Record<string, string>>\n  readonly stdin?: string | Uint8Array\n  /**\n   * Per-exec timeout. Accepts a number (millis), a string like\n   * `\"5 seconds\"`, or a `Duration`.\n   */\n  readonly timeout?: Duration.Input\n}\n\n/**\n * Spawn request — extends {@link CommonExecRequest} with the option\n * to provide stdin as a `Stream<Uint8Array>`. The provider takes one\n * chunk at a time and sends EOF when the stream completes. Useful\n * for piping LLM output into a sandboxed process, or feeding stdin\n * from another stream source. `exec` does not accept streams.\n */\nexport type CommonSpawnRequest = Omit<CommonExecRequest, \"stdin\"> & {\n  readonly stdin?: string | Uint8Array | Stream.Stream<Uint8Array, never, never>\n}\n\nexport type ExecResult = {\n  readonly exitCode: number\n  readonly stdout: string\n  readonly stderr: string\n  readonly durationMs: number\n}\n\n/**\n * Streaming exec output. `Complete` is terminal — the stream\n * completes after emitting it.\n */\nexport type ExecEvent = Data.TaggedEnum<{\n  Stdout: { readonly chunk: Uint8Array }\n  Stderr: { readonly chunk: Uint8Array }\n  Complete: { readonly exitCode: number; readonly durationMs: number }\n}>\n\nexport const ExecEvent = Data.taggedEnum<ExecEvent>()\n\n// ---------------------------------------------------------------------------\n// Filesystem\n// ---------------------------------------------------------------------------\n\nexport type FileEntryKind = \"file\" | \"directory\" | \"symlink\" | \"other\"\n\nexport type FileEntry = {\n  readonly path: string\n  readonly kind: FileEntryKind\n}\n\nexport type SandboxFilesystem = {\n  readonly read: (path: string) => Effect.Effect<Uint8Array, SandboxError.SandboxError>\n  readonly write: (\n    path: string,\n    contents: Uint8Array | string,\n  ) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly remove: (path: string) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly mkdir: (path: string) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly list: (\n    path: string,\n  ) => Effect.Effect<ReadonlyArray<FileEntry>, SandboxError.SandboxError>\n  readonly exists: (path: string) => Effect.Effect<boolean, SandboxError.SandboxError>\n}\n\n// ---------------------------------------------------------------------------\n// Process handle (returned by `spawn`)\n// ---------------------------------------------------------------------------\n\n/**\n * Long-running process handle. Returned by `spawn` in a `Scope.Scope`\n * — the process is killed on scope close. To outlive the calling\n * scope, do `Effect.forkScoped` against a wider scope or use\n * `attach`-style reconnection per the provider's escape hatch.\n */\nexport type ProcessHandle = {\n  readonly pid: number\n  readonly events: Stream.Stream<ExecEvent, SandboxError.SandboxError>\n  readonly kill: Effect.Effect<void, SandboxError.SandboxError>\n  readonly exit: Effect.Effect<{ readonly exitCode: number }, SandboxError.SandboxError>\n}\n\n// ---------------------------------------------------------------------------\n// SandboxInstance — the live handle returned from `create` / `attach`\n// ---------------------------------------------------------------------------\n\n/**\n * Live sandbox handle. Methods are plain `Effect` / `Stream` values\n * — no nullary thunks (`destroy()`, `pause()`) — to match Effect's\n * `Queue.shutdown` / `Fiber.interrupt` style. Destruction is the\n * scope finalizer, not a method here; for the rare \"kill from\n * another fiber\" case use the service-level escape hatch\n * `Sandbox.destroy(id)`.\n */\nexport type SandboxInstance = {\n  readonly id: SandboxId\n  readonly exec: (\n    request: CommonExecRequest,\n  ) => Effect.Effect<ExecResult, SandboxError.SandboxError>\n  readonly execStream: (\n    request: CommonExecRequest,\n  ) => Stream.Stream<ExecEvent, SandboxError.SandboxError>\n  /**\n   * Spawn a background / long-running process. The returned handle is\n   * scoped — the process is killed on scope close. Use this for\n   * \"dev server / watcher / tail -f\" workloads. For one-shot\n   * commands prefer `exec`.\n   */\n  readonly spawn: (\n    request: CommonSpawnRequest,\n  ) => Effect.Effect<ProcessHandle, SandboxError.SandboxError, Scope.Scope>\n  readonly files: SandboxFilesystem\n}\n\n// ---------------------------------------------------------------------------\n// Snapshot / volume / port sub-services (capability-gated)\n// ---------------------------------------------------------------------------\n\nexport type SandboxSnapshotsApi = {\n  readonly create: (\n    from: SandboxInstance,\n    name?: string,\n  ) => Effect.Effect<SnapshotId, SandboxError.SandboxError>\n  readonly destroy: (id: SnapshotId) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly list: Effect.Effect<\n    ReadonlyArray<{ readonly id: SnapshotId; readonly name?: string }>,\n    SandboxError.SandboxError\n  >\n}\n\nexport type SandboxVolumesApi = {\n  readonly create: (\n    name: string,\n    options?: { readonly quotaBytes?: number },\n  ) => Effect.Effect<VolumeId, SandboxError.SandboxError>\n  readonly destroy: (id: VolumeId) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly list: Effect.Effect<\n    ReadonlyArray<{ readonly id: VolumeId; readonly name: string }>,\n    SandboxError.SandboxError\n  >\n}\n\nexport type SandboxPortsApi = {\n  /**\n   * Expose an internal sandbox port as a publicly reachable URL.\n   * Gated by {@link SandboxPortExposure} on the free helper; adapters\n   * that don't ship the marker leave this sub-API out of the public\n   * surface entirely (callers can't construct an Effect against it).\n   */\n  readonly expose: (\n    instance: SandboxInstance,\n    port: number,\n  ) => Effect.Effect<{ readonly url: string }, SandboxError.SandboxError>\n}\n\n// ---------------------------------------------------------------------------\n// Service definition\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider sandbox service.\n *\n * Lifetime model: `create` returns a sandbox handle in `Scope.Scope`.\n * The scope finalizer destroys the sandbox. Use `Effect.scoped` to\n * bound a sandbox's lifetime to a single Effect, or manage the scope\n * explicitly via `Scope.make` for sandboxes that span many calls.\n * This is why there's no `destroy()` method on `SandboxInstance` —\n * the scope is the lifecycle handle.\n *\n * `snapshots` and `volumes` sub-APIs are present on the service but\n * are still capability-gated: provider Layers that don't support\n * them ship implementations that always fail with\n * `SandboxUnsupported`. The free helpers ({@link snapshot},\n * {@link createVolume}) additionally require the corresponding\n * capability marker on R, so misuses surface as type errors at\n * `Effect.provide`, not as runtime failures.\n */\nexport type SandboxService = {\n  /**\n   * Provision a new sandbox. The returned handle's lifetime is\n   * bound to the caller's scope; the sandbox is destroyed on scope\n   * close. To survive the scope, use `attach`-style reconnection or\n   * promote into a wider scope.\n   */\n  readonly create: (\n    request: CommonCreateRequest,\n  ) => Effect.Effect<SandboxInstance, SandboxError.SandboxError, Scope.Scope>\n\n  /**\n   * Re-acquire an existing sandbox by id. The returned handle is\n   * scope-bound but the finalizer is \"detach\" (no destroy) —\n   * appropriate for paused / detached / persistent sandboxes that\n   * outlive any single agent run.\n   */\n  readonly attach: (\n    id: SandboxId,\n  ) => Effect.Effect<SandboxInstance, SandboxError.SandboxError, Scope.Scope>\n\n  /**\n   * Enumerate sandboxes visible to the configured account / project.\n   */\n  readonly list: Effect.Effect<ReadonlyArray<SandboxRef>, SandboxError.SandboxError>\n\n  /**\n   * Escape hatch for destroying a sandbox from outside its owning\n   * scope. Most callers should let the scope finalizer handle this.\n   */\n  readonly destroy: (id: SandboxId) => Effect.Effect<void, SandboxError.SandboxError>\n\n  /** Snapshot management. Capability-gated on {@link SandboxSnapshots}. */\n  readonly snapshots: SandboxSnapshotsApi\n\n  /** Volume management. Capability-gated on {@link SandboxVolumes}. */\n  readonly volumes: SandboxVolumesApi\n\n  /** Port exposure. Capability-gated on {@link SandboxPortExposure}. */\n  readonly ports: SandboxPortsApi\n}\n\nexport class Sandbox extends Context.Service<Sandbox, SandboxService>()(\n  \"@betalyra/effect-uai/Sandbox\",\n) {}\n\n// ---------------------------------------------------------------------------\n// Capability markers\n// ---------------------------------------------------------------------------\n\n/**\n * Capability marker — provided by adapter Layers whose provider\n * supports a hostname-level egress allowlist (matching against host\n * names / wildcards, not just CIDRs). Vercel, Cloudflare, Deno,\n * Microsandbox, Runloop, Anthropic srt ship this marker; Modal and\n * Daytona (CIDR-only) do not.\n *\n * Phantom — the value is `void`; adapters register with\n * `Layer.succeed(SandboxHostnameAllowlist, undefined)`.\n */\nexport class SandboxHostnameAllowlist extends Context.Service<SandboxHostnameAllowlist, void>()(\n  \"@betalyra/effect-uai/capability/SandboxHostnameAllowlist\",\n) {}\n\n/**\n * Capability marker — adapter's provider supports proxy-layer\n * secret rewriting (header injection on outbound HTTPS to bound\n * hosts; the running code never sees the real value). Deno,\n * Cloudflare, E2B, Vercel (firewall transform), Microsandbox,\n * Runloop (Agent Gateway) ship this. Modal, Daytona, CodeSandbox\n * do not.\n */\nexport class SandboxSecretInjection extends Context.Service<SandboxSecretInjection, void>()(\n  \"@betalyra/effect-uai/capability/SandboxSecretInjection\",\n) {}\n\n/**\n * Capability marker — adapter supports snapshot-as-new-sandbox\n * (capture state, restore as a derived sandbox with a fresh id).\n * Distinct from {@link SandboxPauseResume}, which preserves the\n * same id and resumes in place.\n */\nexport class SandboxSnapshots extends Context.Service<SandboxSnapshots, void>()(\n  \"@betalyra/effect-uai/capability/SandboxSnapshots\",\n) {}\n\n/**\n * Capability marker — adapter supports in-place pause and resume on\n * the same sandbox id (E2B, CodeSandbox). Memory + processes are\n * preserved across the pause boundary. Most providers without this\n * marker offer {@link SandboxSnapshots} instead.\n */\nexport class SandboxPauseResume extends Context.Service<SandboxPauseResume, void>()(\n  \"@betalyra/effect-uai/capability/SandboxPauseResume\",\n) {}\n\n/**\n * Capability marker — adapter manages named persistent volumes\n * outside any single sandbox lifecycle (Modal Volume, Daytona,\n * Microsandbox, BoxLite). Providers without this marker leave\n * `Sandbox.volumes.*` returning `SandboxUnsupported`; the free\n * helpers ({@link createVolume}, {@link destroyVolume}) additionally\n * require this marker on R so misuses become a type error.\n */\nexport class SandboxVolumes extends Context.Service<SandboxVolumes, void>()(\n  \"@betalyra/effect-uai/capability/SandboxVolumes\",\n) {}\n\n/**\n * Capability marker — adapter supports a stateful kernel session\n * (Jupyter-style: persistent Python / JS context that returns rich\n * outputs across many `runCode` calls). Cloudflare Code Interpreter\n * and E2B ship this; everyone else expects you to write your own\n * script and `exec` it.\n *\n * The actual `runCode` helper lives separately (not on\n * `SandboxInstance`) because the return shape is different — rich\n * outputs with images/tables, not buffered stdout strings.\n */\nexport class SandboxKernelSession extends Context.Service<SandboxKernelSession, void>()(\n  \"@betalyra/effect-uai/capability/SandboxKernelSession\",\n) {}\n\n/**\n * Capability marker — adapter exposes an interactive PTY session\n * (Runloop, Cloudflare terminal). Distinct from `execStream` which\n * is byte-oriented and one-shot.\n */\nexport class SandboxPty extends Context.Service<SandboxPty, void>()(\n  \"@betalyra/effect-uai/capability/SandboxPty\",\n) {}\n\n/**\n * Capability marker — adapter accepts a user-supplied Dockerfile (or\n * OCI image build) instead of just a registry reference. Vercel does\n * not ship this (fixed AL2023). Deno does not (snapshots only).\n * Most others do.\n */\nexport class SandboxCustomImage extends Context.Service<SandboxCustomImage, void>()(\n  \"@betalyra/effect-uai/capability/SandboxCustomImage\",\n) {}\n\n/**\n * Capability marker — adapter can expose an internal port as a\n * publicly reachable URL. Most cloud providers ship this; local\n * providers (Microsandbox, BoxLite) typically only support\n * host-side port forwarding (handled by ignoring this marker and\n * documenting via the per-provider request type).\n */\nexport class SandboxPortExposure extends Context.Service<SandboxPortExposure, void>()(\n  \"@betalyra/effect-uai/capability/SandboxPortExposure\",\n) {}\n\n// ---------------------------------------------------------------------------\n// Free helpers — accept Sandbox via Context, optionally require markers.\n// ---------------------------------------------------------------------------\n\n/**\n * Provision a sandbox bound to the caller's scope. Drop the\n * `Scope.Scope` requirement with `Effect.scoped`.\n */\nexport const create = (\n  request: CommonCreateRequest,\n): Effect.Effect<SandboxInstance, SandboxError.SandboxError, Sandbox | Scope.Scope> =>\n  Effect.flatMap(Sandbox, (s) => s.create(request))\n\n/**\n * Re-acquire an existing sandbox by id. Same scope semantics as\n * `create`, but the finalizer detaches rather than destroying.\n */\nexport const attach = (\n  id: SandboxId,\n): Effect.Effect<SandboxInstance, SandboxError.SandboxError, Sandbox | Scope.Scope> =>\n  Effect.flatMap(Sandbox, (s) => s.attach(id))\n\n/** Enumerate sandboxes for the configured account / project. */\nexport const list: Effect.Effect<\n  ReadonlyArray<SandboxRef>,\n  SandboxError.SandboxError,\n  Sandbox\n> = Effect.flatMap(Sandbox, (s) => s.list)\n\n/**\n * Escape hatch for destroying a sandbox from outside its owning\n * scope. Most callers should let the scope finalizer handle this\n * automatically.\n */\nexport const destroy = (id: SandboxId): Effect.Effect<void, SandboxError.SandboxError, Sandbox> =>\n  Effect.flatMap(Sandbox, (s) => s.destroy(id))\n\n/**\n * Create a snapshot of a live sandbox. Requires\n * {@link SandboxSnapshots} on the R channel — adapters whose\n * provider doesn't support snapshot-as-new-sandbox don't ship the\n * marker and calls fail at `Effect.provide` with a type error.\n */\nexport const snapshot = (\n  from: SandboxInstance,\n  name?: string,\n): Effect.Effect<SnapshotId, SandboxError.SandboxError, Sandbox | SandboxSnapshots> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxSnapshots\n    return yield* s.snapshots.create(from, name)\n  })\n\n/**\n * Create a named persistent volume. Requires {@link SandboxVolumes}.\n */\nexport const createVolume = (\n  name: string,\n  options?: { readonly quotaBytes?: number },\n): Effect.Effect<VolumeId, SandboxError.SandboxError, Sandbox | SandboxVolumes> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxVolumes\n    return yield* s.volumes.create(name, options)\n  })\n\n/** Destroy a named volume. Requires {@link SandboxVolumes}. */\nexport const destroyVolume = (\n  id: VolumeId,\n): Effect.Effect<void, SandboxError.SandboxError, Sandbox | SandboxVolumes> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxVolumes\n    return yield* s.volumes.destroy(id)\n  })\n\n/** Enumerate persistent volumes. Requires {@link SandboxVolumes}. */\nexport const listVolumes: Effect.Effect<\n  ReadonlyArray<{ readonly id: VolumeId; readonly name: string }>,\n  SandboxError.SandboxError,\n  Sandbox | SandboxVolumes\n> = Effect.gen(function* () {\n  const s = yield* Sandbox\n  yield* SandboxVolumes\n  return yield* s.volumes.list\n})\n\n/** Destroy a snapshot. Requires {@link SandboxSnapshots}. */\nexport const destroySnapshot = (\n  id: SnapshotId,\n): Effect.Effect<void, SandboxError.SandboxError, Sandbox | SandboxSnapshots> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxSnapshots\n    return yield* s.snapshots.destroy(id)\n  })\n\n/** Enumerate snapshots. Requires {@link SandboxSnapshots}. */\nexport const listSnapshots: Effect.Effect<\n  ReadonlyArray<{ readonly id: SnapshotId; readonly name?: string }>,\n  SandboxError.SandboxError,\n  Sandbox | SandboxSnapshots\n> = Effect.gen(function* () {\n  const s = yield* Sandbox\n  yield* SandboxSnapshots\n  return yield* s.snapshots.list\n})\n\n/**\n * Expose an internal port of a live sandbox as a publicly reachable\n * URL. Requires {@link SandboxPortExposure} — adapters whose provider\n * doesn't support runtime port exposure (e.g. Microsandbox, which\n * forwards at create time only) don't ship the marker, and calls\n * fail at `Effect.provide` with a type error.\n */\nexport const exposePort = (\n  instance: SandboxInstance,\n  port: number,\n): Effect.Effect<\n  { readonly url: string },\n  SandboxError.SandboxError,\n  Sandbox | SandboxPortExposure\n> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxPortExposure\n    return yield* s.ports.expose(instance, port)\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,MAAa,YAAY,MAAM,SAAoB;AAanD,MAAa,WAAW,MAAM,SAAmB;AAGjD,MAAa,aAAa,MAAM,SAAqB;AA4BrD,MAAa,WAAW,KAAK,YAAsB;AA2BnD,MAAa,gBAAgB,KAAK,YAA2B;AAmI7D,MAAa,YAAY,KAAK,YAAuB;AAqLrD,IAAa,UAAb,cAA6B,QAAQ,SAAkC,CACrE,+BACD,CAAC;;;;;;;;;;;AAgBF,IAAa,2BAAb,cAA8C,QAAQ,SAAyC,CAC7F,2DACD,CAAC;;;;;;;;;AAUF,IAAa,yBAAb,cAA4C,QAAQ,SAAuC,CACzF,yDACD,CAAC;;;;;;;AAQF,IAAa,mBAAb,cAAsC,QAAQ,SAAiC,CAC7E,mDACD,CAAC;;;;;;;AAQF,IAAa,qBAAb,cAAwC,QAAQ,SAAmC,CACjF,qDACD,CAAC;;;;;;;;;AAUF,IAAa,iBAAb,cAAoC,QAAQ,SAA+B,CACzE,iDACD,CAAC;;;;;;;;;;;;AAaF,IAAa,uBAAb,cAA0C,QAAQ,SAAqC,CACrF,uDACD,CAAC;;;;;;AAOF,IAAa,aAAb,cAAgC,QAAQ,SAA2B,CACjE,6CACD,CAAC;;;;;;;AAQF,IAAa,qBAAb,cAAwC,QAAQ,SAAmC,CACjF,qDACD,CAAC;;;;;;;;AASF,IAAa,sBAAb,cAAyC,QAAQ,SAAoC,CACnF,sDACD,CAAC;;;;;AAUF,MAAa,UACX,YAEA,OAAO,QAAQ,UAAU,MAAM,EAAE,OAAO,QAAQ,CAAC;;;;;AAMnD,MAAa,UACX,OAEA,OAAO,QAAQ,UAAU,MAAM,EAAE,OAAO,GAAG,CAAC;;AAG9C,MAAa,OAIT,OAAO,QAAQ,UAAU,MAAM,EAAE,KAAK;;;;;;AAO1C,MAAa,WAAW,OACtB,OAAO,QAAQ,UAAU,MAAM,EAAE,QAAQ,GAAG,CAAC;;;;;;;AAQ/C,MAAa,YACX,MACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;AACjB,QAAO;AACP,QAAO,OAAO,EAAE,UAAU,OAAO,MAAM,KAAK;EAC5C;;;;AAKJ,MAAa,gBACX,MACA,YAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;AACjB,QAAO;AACP,QAAO,OAAO,EAAE,QAAQ,OAAO,MAAM,QAAQ;EAC7C;;AAGJ,MAAa,iBACX,OAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;AACjB,QAAO;AACP,QAAO,OAAO,EAAE,QAAQ,QAAQ,GAAG;EACnC;;AAGJ,MAAa,cAIT,OAAO,IAAI,aAAa;CAC1B,MAAM,IAAI,OAAO;AACjB,QAAO;AACP,QAAO,OAAO,EAAE,QAAQ;EACxB;;AAGF,MAAa,mBACX,OAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;AACjB,QAAO;AACP,QAAO,OAAO,EAAE,UAAU,QAAQ,GAAG;EACrC;;AAGJ,MAAa,gBAIT,OAAO,IAAI,aAAa;CAC1B,MAAM,IAAI,OAAO;AACjB,QAAO;AACP,QAAO,OAAO,EAAE,UAAU;EAC1B;;;;;;;;AASF,MAAa,cACX,UACA,SAMA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;AACjB,QAAO;AACP,QAAO,OAAO,EAAE,MAAM,OAAO,UAAU,KAAK;EAC5C"}
+{"version":3,"file":"Sandbox.mjs","names":[],"sources":["../../src/sandbox/Sandbox.ts"],"sourcesContent":["import { Brand, Context, Data, type Duration, Effect, Redacted, Scope, Stream } from \"effect\"\nimport type * as SandboxError from \"./SandboxError.js\"\n\n// ---------------------------------------------------------------------------\n// Identity\n// ---------------------------------------------------------------------------\n\n/**\n * Sandbox identifier. Branded `string` so providers don't accidentally\n * accept a raw user-supplied id. Each provider mints these per its own\n * naming scheme (uuid for E2B/Vercel, user-supplied name for\n * Microsandbox/Modal, …); the core code treats them opaquely.\n *\n * Mint via the value-level `SandboxId(...)` smart constructor instead\n * of `as SandboxId` casts.\n */\nexport type SandboxId = Brand.Branded<string, \"SandboxId\">\nexport const SandboxId = Brand.nominal<SandboxId>()\n\n/**\n * Reference returned by `list`. Carries just enough to call `attach` —\n * provider-specific metadata (createdAt, region, tags, …) lives on the\n * narrowed per-provider ref.\n */\nexport type SandboxRef = {\n  readonly id: SandboxId\n  readonly name?: string\n}\n\nexport type VolumeId = Brand.Branded<string, \"VolumeId\">\nexport const VolumeId = Brand.nominal<VolumeId>()\n\nexport type SnapshotId = Brand.Branded<string, \"SnapshotId\">\nexport const SnapshotId = Brand.nominal<SnapshotId>()\n\n// ---------------------------------------------------------------------------\n// Image / runtime selection\n// ---------------------------------------------------------------------------\n\n/**\n * What runtime / filesystem to boot the sandbox from.\n *\n * - `Default` — provider picks its house image (Vercel: Amazon Linux\n *   2023; Microsandbox: requires user image but a builder default may\n *   apply, …). Use when you don't care what's pre-installed.\n * - `Registry` — an OCI image reference. Supported by every provider\n *   except those with a fixed base (Vercel ignores this and the\n *   request-schema rejects at decode).\n * - `Snapshot` — restore from a captured state. Gated by\n *   {@link SandboxSnapshots} at the call site — the marker is provided\n *   by adapters whose provider supports snapshot-as-image.\n * - `Dockerfile` — provider builds a custom image from a Dockerfile.\n *   Gated by {@link SandboxCustomImage}.\n */\nexport type ImageRef = Data.TaggedEnum<{\n  Default: {}\n  Registry: { readonly ref: string }\n  Snapshot: { readonly id: SnapshotId }\n  Dockerfile: { readonly contents: string }\n}>\n\nexport const ImageRef = Data.taggedEnum<ImageRef>()\n\n// ---------------------------------------------------------------------------\n// Network policy + secrets\n// ---------------------------------------------------------------------------\n\n/**\n * Outbound network policy for a sandbox.\n *\n * - `Open` — no egress restriction. The provider's defaults apply\n *   (e.g. Microsandbox's \"public-only\" still blocks private ranges).\n * - `Blocked` — fully airgapped, no outbound connectivity at all.\n * - `Allowlist` — only the listed hosts / CIDRs may be reached.\n *\n * Providers vary in what they honour: hostname-allowlist requires\n * {@link SandboxHostnameAllowlist}; CIDR-only providers ignore `hosts`\n * and the adapter rejects at decode if `hosts` is non-empty.\n */\nexport type NetworkPolicy = Data.TaggedEnum<{\n  Open: {}\n  Blocked: {}\n  Allowlist: {\n    readonly hosts?: ReadonlyArray<string>\n    readonly cidrs?: ReadonlyArray<string>\n  }\n}>\n\nexport const NetworkPolicy = Data.taggedEnum<NetworkPolicy>()\n\n/**\n * A secret bound to a sandbox at create time. The code inside the\n * sandbox sees only a placeholder (`$MSB_<NAME>` for Microsandbox,\n * `{name}` for Vercel header-injection, etc.); the real `value` lives\n * on the provider's proxy and is substituted on outbound HTTPS to\n * `hosts`.\n *\n * Requires the {@link SandboxSecretInjection} capability marker —\n * provider Layers without proxy-layer secret rewriting do not ship the\n * marker and consumer code fails at `Effect.provide` with a type\n * error.\n *\n * `header` is the request header to inject (default\n * `\"Authorization: Bearer <value>\"`). Providers that do not let\n * callers pick the header (Microsandbox's `secretEnv` shorthand)\n * silently ignore this field; providers that require an explicit\n * header (Vercel's `transform.headers`) fail at decode if it's absent.\n */\nexport type BoundSecret = {\n  readonly name: string\n  readonly value: Redacted.Redacted<string>\n  readonly hosts: ReadonlyArray<string>\n  readonly header?: string\n}\n\n// ---------------------------------------------------------------------------\n// Volumes (capability-gated on `SandboxVolumes`)\n// ---------------------------------------------------------------------------\n\nexport type VolumeMount = {\n  readonly id: VolumeId\n  readonly mountPath: string\n  readonly readonly?: boolean\n}\n\n// ---------------------------------------------------------------------------\n// Create / exec request shapes\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider create request. Provider-specific knobs (region,\n * cpus, memory, template id, …) live on each provider's narrowed\n * request type which extends this.\n *\n * Fields a provider can't honour fail at **decode time** (per the\n * per-provider request schema), not silently at runtime. The\n * ComputeSDK anti-pattern of \"drop unsupported fields\" is the\n * footgun we're avoiding.\n */\nexport type CommonCreateRequest = {\n  /** Image / snapshot to boot from. Omit for the provider's default. */\n  readonly image?: ImageRef\n  /**\n   * Idle / hard timeout. Accepts a number (millis), a string like\n   * `\"30 seconds\"`, or a `Duration`. Providers default differently.\n   */\n  readonly timeout?: Duration.Input\n  /**\n   * Env vars exposed to the sandbox. NOT for secrets you want hidden\n   * from the running code — use {@link BoundSecret} instead.\n   */\n  readonly env?: Readonly<Record<string, string>>\n  /** Outbound network policy. */\n  readonly network?: NetworkPolicy\n  /**\n   * Bound secrets — code inside the sandbox sees a placeholder; the\n   * proxy substitutes the real value on outbound HTTPS to listed hosts.\n   * Capability-gated on {@link SandboxSecretInjection}.\n   */\n  readonly secrets?: ReadonlyArray<BoundSecret>\n  /**\n   * Persistent volumes to mount. Volumes are created via\n   * `Sandbox.volumes.create` and survive sandbox lifetime.\n   * Capability-gated on {@link SandboxVolumes}.\n   */\n  readonly volumes?: ReadonlyArray<VolumeMount>\n}\n\n/**\n * Cross-provider exec request. Background / long-running processes\n * use `spawn` instead of `exec`; the semantics differ enough that\n * overloading `exec` with a `detached` flag was rejected during\n * design.\n */\nexport type CommonExecRequest = {\n  /**\n   * Argv-style command. Pass a string for \"run this through the\n   * shell\" semantics (provider-dependent — most use `sh -c`); pass\n   * an array for direct argv with no shell parsing.\n   */\n  readonly cmd: string | ReadonlyArray<string>\n  readonly cwd?: string\n  readonly env?: Readonly<Record<string, string>>\n  readonly stdin?: string | Uint8Array\n  /**\n   * Per-exec timeout. Accepts a number (millis), a string like\n   * `\"5 seconds\"`, or a `Duration`.\n   */\n  readonly timeout?: Duration.Input\n}\n\n/**\n * Spawn request — extends {@link CommonExecRequest} with the option\n * to provide stdin as a `Stream<Uint8Array>`. The provider takes one\n * chunk at a time and sends EOF when the stream completes. Useful\n * for piping LLM output into a sandboxed process, or feeding stdin\n * from another stream source. `exec` does not accept streams.\n */\nexport type CommonSpawnRequest = Omit<CommonExecRequest, \"stdin\"> & {\n  readonly stdin?: string | Uint8Array | Stream.Stream<Uint8Array, never, never>\n}\n\nexport type ExecResult = {\n  readonly exitCode: number\n  readonly stdout: string\n  readonly stderr: string\n  readonly durationMs: number\n}\n\n/**\n * Streaming exec output. `Complete` is terminal — the stream\n * completes after emitting it.\n */\nexport type ExecEvent = Data.TaggedEnum<{\n  Stdout: { readonly chunk: Uint8Array }\n  Stderr: { readonly chunk: Uint8Array }\n  Complete: { readonly exitCode: number; readonly durationMs: number }\n}>\n\nexport const ExecEvent = Data.taggedEnum<ExecEvent>()\n\n// ---------------------------------------------------------------------------\n// Filesystem\n// ---------------------------------------------------------------------------\n\nexport type FileEntryKind = \"file\" | \"directory\" | \"symlink\" | \"other\"\n\nexport type FileEntry = {\n  readonly path: string\n  readonly kind: FileEntryKind\n}\n\nexport type SandboxFilesystem = {\n  readonly read: (path: string) => Effect.Effect<Uint8Array, SandboxError.SandboxError>\n  readonly write: (\n    path: string,\n    contents: Uint8Array | string,\n  ) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly remove: (path: string) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly mkdir: (path: string) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly list: (\n    path: string,\n  ) => Effect.Effect<ReadonlyArray<FileEntry>, SandboxError.SandboxError>\n  readonly exists: (path: string) => Effect.Effect<boolean, SandboxError.SandboxError>\n}\n\n// ---------------------------------------------------------------------------\n// Process handle (returned by `spawn`)\n// ---------------------------------------------------------------------------\n\n/**\n * Long-running process handle. Returned by `spawn` in a `Scope.Scope`\n * — the process is killed on scope close. To outlive the calling\n * scope, do `Effect.forkScoped` against a wider scope or use\n * `attach`-style reconnection per the provider's escape hatch.\n */\nexport type ProcessHandle = {\n  readonly pid: number\n  readonly events: Stream.Stream<ExecEvent, SandboxError.SandboxError>\n  readonly kill: Effect.Effect<void, SandboxError.SandboxError>\n  readonly exit: Effect.Effect<{ readonly exitCode: number }, SandboxError.SandboxError>\n}\n\n// ---------------------------------------------------------------------------\n// SandboxInstance — the live handle returned from `create` / `attach`\n// ---------------------------------------------------------------------------\n\n/**\n * Live sandbox handle. Methods are plain `Effect` / `Stream` values\n * — no nullary thunks (`destroy()`, `pause()`) — to match Effect's\n * `Queue.shutdown` / `Fiber.interrupt` style. Destruction is the\n * scope finalizer, not a method here; for the rare \"kill from\n * another fiber\" case use the service-level escape hatch\n * `Sandbox.destroy(id)`.\n */\nexport type SandboxInstance = {\n  readonly id: SandboxId\n  readonly exec: (\n    request: CommonExecRequest,\n  ) => Effect.Effect<ExecResult, SandboxError.SandboxError>\n  readonly execStream: (\n    request: CommonExecRequest,\n  ) => Stream.Stream<ExecEvent, SandboxError.SandboxError>\n  /**\n   * Spawn a background / long-running process. The returned handle is\n   * scoped — the process is killed on scope close. Use this for\n   * \"dev server / watcher / tail -f\" workloads. For one-shot\n   * commands prefer `exec`.\n   */\n  readonly spawn: (\n    request: CommonSpawnRequest,\n  ) => Effect.Effect<ProcessHandle, SandboxError.SandboxError, Scope.Scope>\n  readonly files: SandboxFilesystem\n}\n\n// ---------------------------------------------------------------------------\n// Snapshot / volume / port sub-services (capability-gated)\n// ---------------------------------------------------------------------------\n\nexport type SandboxSnapshotsApi = {\n  readonly create: (\n    from: SandboxInstance,\n    name?: string,\n  ) => Effect.Effect<SnapshotId, SandboxError.SandboxError>\n  readonly destroy: (id: SnapshotId) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly list: Effect.Effect<\n    ReadonlyArray<{ readonly id: SnapshotId; readonly name?: string }>,\n    SandboxError.SandboxError\n  >\n}\n\nexport type SandboxVolumesApi = {\n  readonly create: (\n    name: string,\n    options?: { readonly quotaBytes?: number },\n  ) => Effect.Effect<VolumeId, SandboxError.SandboxError>\n  readonly destroy: (id: VolumeId) => Effect.Effect<void, SandboxError.SandboxError>\n  readonly list: Effect.Effect<\n    ReadonlyArray<{ readonly id: VolumeId; readonly name: string }>,\n    SandboxError.SandboxError\n  >\n}\n\nexport type SandboxPortsApi = {\n  /**\n   * Expose an internal sandbox port as a publicly reachable URL.\n   * Gated by {@link SandboxPortExposure} on the free helper; adapters\n   * that don't ship the marker leave this sub-API out of the public\n   * surface entirely (callers can't construct an Effect against it).\n   */\n  readonly expose: (\n    instance: SandboxInstance,\n    port: number,\n  ) => Effect.Effect<{ readonly url: string }, SandboxError.SandboxError>\n}\n\n// ---------------------------------------------------------------------------\n// Service definition\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider sandbox service.\n *\n * Lifetime model: `create` returns a sandbox handle in `Scope.Scope`.\n * The scope finalizer destroys the sandbox. Use `Effect.scoped` to\n * bound a sandbox's lifetime to a single Effect, or manage the scope\n * explicitly via `Scope.make` for sandboxes that span many calls.\n * This is why there's no `destroy()` method on `SandboxInstance` —\n * the scope is the lifecycle handle.\n *\n * `snapshots` and `volumes` sub-APIs are present on the service but\n * are still capability-gated: provider Layers that don't support\n * them ship implementations that always fail with\n * `SandboxUnsupported`. The free helpers ({@link snapshot},\n * {@link createVolume}) additionally require the corresponding\n * capability marker on R, so misuses surface as type errors at\n * `Effect.provide`, not as runtime failures.\n */\nexport type SandboxService = {\n  /**\n   * Provision a new sandbox. The returned handle's lifetime is\n   * bound to the caller's scope; the sandbox is destroyed on scope\n   * close. To survive the scope, use `attach`-style reconnection or\n   * promote into a wider scope.\n   */\n  readonly create: (\n    request: CommonCreateRequest,\n  ) => Effect.Effect<SandboxInstance, SandboxError.SandboxError, Scope.Scope>\n\n  /**\n   * Re-acquire an existing sandbox by id. The returned handle is\n   * scope-bound but the finalizer is \"detach\" (no destroy) —\n   * appropriate for paused / detached / persistent sandboxes that\n   * outlive any single agent run.\n   */\n  readonly attach: (\n    id: SandboxId,\n  ) => Effect.Effect<SandboxInstance, SandboxError.SandboxError, Scope.Scope>\n\n  /**\n   * Enumerate sandboxes visible to the configured account / project.\n   */\n  readonly list: Effect.Effect<ReadonlyArray<SandboxRef>, SandboxError.SandboxError>\n\n  /**\n   * Escape hatch for destroying a sandbox from outside its owning\n   * scope. Most callers should let the scope finalizer handle this.\n   */\n  readonly destroy: (id: SandboxId) => Effect.Effect<void, SandboxError.SandboxError>\n\n  /** Snapshot management. Capability-gated on {@link SandboxSnapshots}. */\n  readonly snapshots: SandboxSnapshotsApi\n\n  /** Volume management. Capability-gated on {@link SandboxVolumes}. */\n  readonly volumes: SandboxVolumesApi\n\n  /** Port exposure. Capability-gated on {@link SandboxPortExposure}. */\n  readonly ports: SandboxPortsApi\n}\n\nexport class Sandbox extends Context.Service<Sandbox, SandboxService>()(\n  \"@betalyra/effect-uai/Sandbox\",\n) {}\n\n// ---------------------------------------------------------------------------\n// Capability markers\n// ---------------------------------------------------------------------------\n\n/**\n * Capability marker — provided by adapter Layers whose provider\n * supports a hostname-level egress allowlist (matching against host\n * names / wildcards, not just CIDRs). Vercel, Cloudflare, Deno,\n * Microsandbox, Runloop, Anthropic srt ship this marker; Modal and\n * Daytona (CIDR-only) do not.\n *\n * Phantom — the value is `void`; adapters register with\n * `Layer.succeed(SandboxHostnameAllowlist, undefined)`.\n */\nexport class SandboxHostnameAllowlist extends Context.Service<SandboxHostnameAllowlist, void>()(\n  \"@betalyra/effect-uai/capability/SandboxHostnameAllowlist\",\n) {}\n\n/**\n * Capability marker — adapter's provider supports proxy-layer\n * secret rewriting (header injection on outbound HTTPS to bound\n * hosts; the running code never sees the real value). Deno,\n * Cloudflare, E2B, Vercel (firewall transform), Microsandbox,\n * Runloop (Agent Gateway) ship this. Modal, Daytona, CodeSandbox\n * do not.\n */\nexport class SandboxSecretInjection extends Context.Service<SandboxSecretInjection, void>()(\n  \"@betalyra/effect-uai/capability/SandboxSecretInjection\",\n) {}\n\n/**\n * Capability marker — adapter supports snapshot-as-new-sandbox\n * (capture state, restore as a derived sandbox with a fresh id).\n * Distinct from {@link SandboxPauseResume}, which preserves the\n * same id and resumes in place.\n */\nexport class SandboxSnapshots extends Context.Service<SandboxSnapshots, void>()(\n  \"@betalyra/effect-uai/capability/SandboxSnapshots\",\n) {}\n\n/**\n * Capability marker — adapter supports in-place pause and resume on\n * the same sandbox id (E2B, CodeSandbox). Memory + processes are\n * preserved across the pause boundary. Most providers without this\n * marker offer {@link SandboxSnapshots} instead.\n */\nexport class SandboxPauseResume extends Context.Service<SandboxPauseResume, void>()(\n  \"@betalyra/effect-uai/capability/SandboxPauseResume\",\n) {}\n\n/**\n * Capability marker — adapter manages named persistent volumes\n * outside any single sandbox lifecycle (Modal Volume, Daytona,\n * Microsandbox, BoxLite). Providers without this marker leave\n * `Sandbox.volumes.*` returning `SandboxUnsupported`; the free\n * helpers ({@link createVolume}, {@link destroyVolume}) additionally\n * require this marker on R so misuses become a type error.\n */\nexport class SandboxVolumes extends Context.Service<SandboxVolumes, void>()(\n  \"@betalyra/effect-uai/capability/SandboxVolumes\",\n) {}\n\n/**\n * Capability marker — adapter supports a stateful kernel session\n * (Jupyter-style: persistent Python / JS context that returns rich\n * outputs across many `runCode` calls). Cloudflare Code Interpreter\n * and E2B ship this; everyone else expects you to write your own\n * script and `exec` it.\n *\n * The actual `runCode` helper lives separately (not on\n * `SandboxInstance`) because the return shape is different — rich\n * outputs with images/tables, not buffered stdout strings.\n */\nexport class SandboxKernelSession extends Context.Service<SandboxKernelSession, void>()(\n  \"@betalyra/effect-uai/capability/SandboxKernelSession\",\n) {}\n\n/**\n * Capability marker — adapter exposes an interactive PTY session\n * (Runloop, Cloudflare terminal). Distinct from `execStream` which\n * is byte-oriented and one-shot.\n */\nexport class SandboxPty extends Context.Service<SandboxPty, void>()(\n  \"@betalyra/effect-uai/capability/SandboxPty\",\n) {}\n\n/**\n * Capability marker — adapter accepts a user-supplied Dockerfile (or\n * OCI image build) instead of just a registry reference. Vercel does\n * not ship this (fixed AL2023). Deno does not (snapshots only).\n * Most others do.\n */\nexport class SandboxCustomImage extends Context.Service<SandboxCustomImage, void>()(\n  \"@betalyra/effect-uai/capability/SandboxCustomImage\",\n) {}\n\n/**\n * Capability marker — adapter can expose an internal port as a\n * publicly reachable URL. Most cloud providers ship this; local\n * providers (Microsandbox, BoxLite) typically only support\n * host-side port forwarding (handled by ignoring this marker and\n * documenting via the per-provider request type).\n */\nexport class SandboxPortExposure extends Context.Service<SandboxPortExposure, void>()(\n  \"@betalyra/effect-uai/capability/SandboxPortExposure\",\n) {}\n\n// ---------------------------------------------------------------------------\n// Free helpers — accept Sandbox via Context, optionally require markers.\n// ---------------------------------------------------------------------------\n\n/**\n * Provision a sandbox bound to the caller's scope. Drop the\n * `Scope.Scope` requirement with `Effect.scoped`.\n */\nexport const create = (\n  request: CommonCreateRequest,\n): Effect.Effect<SandboxInstance, SandboxError.SandboxError, Sandbox | Scope.Scope> =>\n  Effect.flatMap(Sandbox, (s) => s.create(request))\n\n/**\n * Re-acquire an existing sandbox by id. Same scope semantics as\n * `create`, but the finalizer detaches rather than destroying.\n */\nexport const attach = (\n  id: SandboxId,\n): Effect.Effect<SandboxInstance, SandboxError.SandboxError, Sandbox | Scope.Scope> =>\n  Effect.flatMap(Sandbox, (s) => s.attach(id))\n\n/** Enumerate sandboxes for the configured account / project. */\nexport const list: Effect.Effect<\n  ReadonlyArray<SandboxRef>,\n  SandboxError.SandboxError,\n  Sandbox\n> = Effect.flatMap(Sandbox, (s) => s.list)\n\n/**\n * Escape hatch for destroying a sandbox from outside its owning\n * scope. Most callers should let the scope finalizer handle this\n * automatically.\n */\nexport const destroy = (id: SandboxId): Effect.Effect<void, SandboxError.SandboxError, Sandbox> =>\n  Effect.flatMap(Sandbox, (s) => s.destroy(id))\n\n/**\n * Create a snapshot of a live sandbox. Requires\n * {@link SandboxSnapshots} on the R channel — adapters whose\n * provider doesn't support snapshot-as-new-sandbox don't ship the\n * marker and calls fail at `Effect.provide` with a type error.\n */\nexport const snapshot = (\n  from: SandboxInstance,\n  name?: string,\n): Effect.Effect<SnapshotId, SandboxError.SandboxError, Sandbox | SandboxSnapshots> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxSnapshots\n    return yield* s.snapshots.create(from, name)\n  })\n\n/**\n * Create a named persistent volume. Requires {@link SandboxVolumes}.\n */\nexport const createVolume = (\n  name: string,\n  options?: { readonly quotaBytes?: number },\n): Effect.Effect<VolumeId, SandboxError.SandboxError, Sandbox | SandboxVolumes> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxVolumes\n    return yield* s.volumes.create(name, options)\n  })\n\n/** Destroy a named volume. Requires {@link SandboxVolumes}. */\nexport const destroyVolume = (\n  id: VolumeId,\n): Effect.Effect<void, SandboxError.SandboxError, Sandbox | SandboxVolumes> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxVolumes\n    return yield* s.volumes.destroy(id)\n  })\n\n/** Enumerate persistent volumes. Requires {@link SandboxVolumes}. */\nexport const listVolumes: Effect.Effect<\n  ReadonlyArray<{ readonly id: VolumeId; readonly name: string }>,\n  SandboxError.SandboxError,\n  Sandbox | SandboxVolumes\n> = Effect.gen(function* () {\n  const s = yield* Sandbox\n  yield* SandboxVolumes\n  return yield* s.volumes.list\n})\n\n/** Destroy a snapshot. Requires {@link SandboxSnapshots}. */\nexport const destroySnapshot = (\n  id: SnapshotId,\n): Effect.Effect<void, SandboxError.SandboxError, Sandbox | SandboxSnapshots> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxSnapshots\n    return yield* s.snapshots.destroy(id)\n  })\n\n/** Enumerate snapshots. Requires {@link SandboxSnapshots}. */\nexport const listSnapshots: Effect.Effect<\n  ReadonlyArray<{ readonly id: SnapshotId; readonly name?: string }>,\n  SandboxError.SandboxError,\n  Sandbox | SandboxSnapshots\n> = Effect.gen(function* () {\n  const s = yield* Sandbox\n  yield* SandboxSnapshots\n  return yield* s.snapshots.list\n})\n\n/**\n * Expose an internal port of a live sandbox as a publicly reachable\n * URL. Requires {@link SandboxPortExposure} — adapters whose provider\n * doesn't support runtime port exposure (e.g. Microsandbox, which\n * forwards at create time only) don't ship the marker, and calls\n * fail at `Effect.provide` with a type error.\n */\nexport const exposePort = (\n  instance: SandboxInstance,\n  port: number,\n): Effect.Effect<\n  { readonly url: string },\n  SandboxError.SandboxError,\n  Sandbox | SandboxPortExposure\n> =>\n  Effect.gen(function* () {\n    const s = yield* Sandbox\n    yield* SandboxPortExposure\n    return yield* s.ports.expose(instance, port)\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,MAAa,YAAY,MAAM,QAAmB;AAalD,MAAa,WAAW,MAAM,QAAkB;AAGhD,MAAa,aAAa,MAAM,QAAoB;AA4BpD,MAAa,WAAW,KAAK,WAAqB;AA2BlD,MAAa,gBAAgB,KAAK,WAA0B;AAmI5D,MAAa,YAAY,KAAK,WAAsB;AAqLpD,IAAa,UAAb,cAA6B,QAAQ,QAAiC,CAAC,CACrE,8BACF,CAAC,CAAC,CAAC;;;;;;;;;;;AAgBH,IAAa,2BAAb,cAA8C,QAAQ,QAAwC,CAAC,CAC7F,0DACF,CAAC,CAAC,CAAC;;;;;;;;;AAUH,IAAa,yBAAb,cAA4C,QAAQ,QAAsC,CAAC,CACzF,wDACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,mBAAb,cAAsC,QAAQ,QAAgC,CAAC,CAC7E,kDACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,qBAAb,cAAwC,QAAQ,QAAkC,CAAC,CACjF,oDACF,CAAC,CAAC,CAAC;;;;;;;;;AAUH,IAAa,iBAAb,cAAoC,QAAQ,QAA8B,CAAC,CACzE,gDACF,CAAC,CAAC,CAAC;;;;;;;;;;;;AAaH,IAAa,uBAAb,cAA0C,QAAQ,QAAoC,CAAC,CACrF,sDACF,CAAC,CAAC,CAAC;;;;;;AAOH,IAAa,aAAb,cAAgC,QAAQ,QAA0B,CAAC,CACjE,4CACF,CAAC,CAAC,CAAC;;;;;;;AAQH,IAAa,qBAAb,cAAwC,QAAQ,QAAkC,CAAC,CACjF,oDACF,CAAC,CAAC,CAAC;;;;;;;;AASH,IAAa,sBAAb,cAAyC,QAAQ,QAAmC,CAAC,CACnF,qDACF,CAAC,CAAC,CAAC;;;;;AAUH,MAAa,UACX,YAEA,OAAO,QAAQ,UAAU,MAAM,EAAE,OAAO,OAAO,CAAC;;;;;AAMlD,MAAa,UACX,OAEA,OAAO,QAAQ,UAAU,MAAM,EAAE,OAAO,EAAE,CAAC;;AAG7C,MAAa,OAIT,OAAO,QAAQ,UAAU,MAAM,EAAE,IAAI;;;;;;AAOzC,MAAa,WAAW,OACtB,OAAO,QAAQ,UAAU,MAAM,EAAE,QAAQ,EAAE,CAAC;;;;;;;AAQ9C,MAAa,YACX,MACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;CACjB,OAAO;CACP,OAAO,OAAO,EAAE,UAAU,OAAO,MAAM,IAAI;AAC7C,CAAC;;;;AAKH,MAAa,gBACX,MACA,YAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;CACjB,OAAO;CACP,OAAO,OAAO,EAAE,QAAQ,OAAO,MAAM,OAAO;AAC9C,CAAC;;AAGH,MAAa,iBACX,OAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;CACjB,OAAO;CACP,OAAO,OAAO,EAAE,QAAQ,QAAQ,EAAE;AACpC,CAAC;;AAGH,MAAa,cAIT,OAAO,IAAI,aAAa;CAC1B,MAAM,IAAI,OAAO;CACjB,OAAO;CACP,OAAO,OAAO,EAAE,QAAQ;AAC1B,CAAC;;AAGD,MAAa,mBACX,OAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;CACjB,OAAO;CACP,OAAO,OAAO,EAAE,UAAU,QAAQ,EAAE;AACtC,CAAC;;AAGH,MAAa,gBAIT,OAAO,IAAI,aAAa;CAC1B,MAAM,IAAI,OAAO;CACjB,OAAO;CACP,OAAO,OAAO,EAAE,UAAU;AAC5B,CAAC;;;;;;;;AASD,MAAa,cACX,UACA,SAMA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO;CACjB,OAAO;CACP,OAAO,OAAO,EAAE,MAAM,OAAO,UAAU,IAAI;AAC7C,CAAC"}

package/dist/sandbox/SandboxError.d.mts

@@ -1,2 +1,2 @@
-import { a as SandboxError, c as SandboxInvalidRequest, d as SandboxQuotaExceeded, f as SandboxTimeout, i as SandboxCreateFailed, l as SandboxNetworkPolicyDenied, n as SandboxAuthFailed, p as SandboxUnsupported, r as SandboxAuthSubtype, s as SandboxExecFailed, t as SandboxAlreadyExists, u as SandboxNotFound } from "../SandboxError-CIrVDOMV.mjs";
+import { a as SandboxError, c as SandboxInvalidRequest, d as SandboxQuotaExceeded, f as SandboxTimeout, i as SandboxCreateFailed, l as SandboxNetworkPolicyDenied, n as SandboxAuthFailed, p as SandboxUnsupported, r as SandboxAuthSubtype, s as SandboxExecFailed, t as SandboxAlreadyExists, u as SandboxNotFound } from "../SandboxError-BN8b28Bh.mjs";
 export { SandboxAlreadyExists, SandboxAuthFailed, SandboxAuthSubtype, SandboxCreateFailed, SandboxError, SandboxExecFailed, SandboxInvalidRequest, SandboxNetworkPolicyDenied, SandboxNotFound, SandboxQuotaExceeded, SandboxTimeout, SandboxUnsupported };

package/dist/sandbox/SandboxError.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { Data } from "effect";
 //#region src/sandbox/SandboxError.ts
 var SandboxError_exports = /* @__PURE__ */ __exportAll({