@effect-uai/core 0.5.2 → 0.6.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sandbox.d.mts","names":[],"sources":["../../src/sandbox/Sandbox.ts"],"mappings":";;;;;;;;;;;;;;;;;KAgBY,SAAA,GAAY,KAAA,CAAM,OAAA;AAAA,cACjB,SAAA,EAAS,KAAA,CAAA,WAAA,CAAA,SAAA;;;;;;KAOV,UAAA;EAAA,SACD,EAAA,EAAI,SAAA;EAAA,SACJ,IAAA;AAAA;AAAA,KAGC,QAAA,GAAW,KAAA,CAAM,OAAA;AAAA,cAChB,QAAA,EAAQ,KAAA,CAAA,WAAA,CAAA,QAAA;AAAA,KAET,UAAA,GAAa,KAAA,CAAM,OAAA;AAAA,cAClB,UAAA,EAAU,KAAA,CAAA,WAAA,CAAA,UAAA;;;;;;;;;;;;;;;;KAqBX,QAAA,GAAW,IAAA,CAAK,UAAA;EAC1B,OAAA;EACA,QAAA;IAAA,SAAqB,GAAA;EAAA;EACrB,QAAA;IAAA,SAAqB,EAAA,EAAI,UAAA;EAAA;EACzB,UAAA;IAAA,SAAuB,QAAA;EAAA;AAAA;AAAA,cAGZ,QAAA;EAAA;;;;;;;;;iBAJc,UAAA;EAAA;EAAA;;;;;;;;;;;;;;;iBAAA,UAAA;EAAA;IAAA;;;;;;;;;;;;;;;;;;qBAAA,UAAA;MAAA;MAAA;;;;;;;;;;;mBAAA,UAAA;IAAA;MAAA;;;;;;;;;;;;;qBAAA,UAAA;MAAA;MAAA;;;;;;;;;;;mBAAA,UAAA;IAAA;MAAA;;;;;;;;;;;;;;;;;KAsBf,aAAA,GAAgB,IAAA,CAAK,UAAA;EAC/B,IAAA;EACA,OAAA;EACA,SAAA;IAAA,SACW,KAAA,GAAQ,aAAA;IAAA,SACR,KAAA,GAAQ,aAAA;EAAA;AAAA;AAAA,cAIR,aAAA;EAAA;;;;;;;;qBALQ,aAAA;IAAA,iBACA,aAAA;EAAA;EAAA;;;;;;;;;;qBADA,aAAA;IAAA,iBACA,aAAA;EAAA;IAAA;;;;;;;;;;;;yBADA,aAAA;QAAA,iBACA,aAAA;MAAA;IAAA;;;;;;uBADA,aAAA;MAAA,iBACA,aAAA;IAAA;;;;;;;;;;yBADA,aAAA;QAAA,iBACA,aAAA;MAAA;IAAA;;;;;;uBADA,aAAA;MAAA,iBACA,aAAA;IAAA;;;;;;;;;;;;;;;;;;;;;KAwBT,WAAA;EAAA,SACD,IAAA;EAAA,SACA,KAAA,EAAO,QAAA,CAAS,QAAA;EAAA,SAChB,KAAA,EAAO,aAAA;EAAA,SACP,MAAA;AAAA;AAAA,KAOC,WAAA;EAAA,SACD,EAAA,EAAI,QAAA;EAAA,SACJ,SAAA;EAAA,SACA,QAAA;AAAA;;;;;;;;;;;KAiBC,mBAAA;EAvDC,+EAyDF,KAAA,GAAQ,QAAA;EAzDe;;AAIlC;;EAJkC,SA8DvB,OAAA,GAAU,QAAA,CAAS,KAAA;;;;;WAKnB,GAAA,GAAM,QAAA,CAAS,MAAA;WAEf,OAAA,GAAU,aAAA;;;;;;WAMV,OAAA,GAAU,aAAA,CAAc,WAAA;;;;;;WAMxB,OAAA,GAAU,aAAA,CAAc,WAAA;AAAA;;;;;;;KASvB,iBAAA;;;;;;WAMD,GAAA,WAAc,aAAA;EAAA,SACd,GAAA;EAAA,SACA,GAAA,GAAM,QAAA,CAAS,MAAA;EAAA,SACf,KAAA,YAAiB,UAAA;;;;;WAKjB,OAAA,GAAU,QAAA,CAAS,KAAA;AAAA;;;;;;;;KAUlB,kBAAA,GAAqB,IAAA,CAAK,iBAAA;EAAA,SAC3B,KAAA,YAAiB,UAAA,GAAa,MAAA,CAAO,MAAA,CAAO,UAAA;AAAA;AAAA,KAG3C,UAAA;EAAA,SACD,QAAA;EAAA,SACA,MAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;AAAA;;;;;KAOC,SAAA,GAAY,IAAA,CAAK,UAAA;EAC3B,MAAA;IAAA,SAAmB,KAAA,EAAO,UAAA;EAAA;EAC1B,MAAA;IAAA,SAAmB,KAAA,EAAO,UAAA;EAAA;EAC1B,QAAA;IAAA,SAAqB,QAAA;IAAA,SAA2B,UAAA;EAAA;AAAA;AAAA,cAGrC,SAAA;EAAA;;oBALe,UAAA;EAAA;EAAA;;oBACA,UAAA;EAAA;EAAA;;;;;;;oBADA,UAAA;EAAA;IAAA;;;oBACA,UAAA;EAAA;IAAA;;;;;;;;;;;;wBADA,UAAA;MAAA;MAAA;;wBACA,UAAA;MAAA;MAAA;;;;;;;sBADA,UAAA;IAAA;MAAA;sBACA,UAAA;IAAA;MAAA;;;;;;;wBADA,UAAA;MAAA;MAAA;;wBACA,UAAA;MAAA;MAAA;;;;;;;sBADA,UAAA;IAAA;MAAA;sBACA,UAAA;IAAA;MAAA;;;;;;KAUhB,aAAA;AAAA,KAEA,SAAA;EAAA,SACD,IAAA;EAAA,SACA,IAAA,EAAM,aAAA;AAAA;AAAA,KAGL,iBAAA;EAAA,SACD,IAAA,GAAO,IAAA,aAAiB,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,YAAA;EAAA,SAClD,KAAA,GACP,IAAA,UACA,QAAA,EAAU,UAAA,cACP,MAAA,CAAO,MAAA,OAAa,YAAA;EAAA,SAChB,MAAA,GAAS,IAAA,aAAiB,MAAA,CAAO,MAAA,OAAa,YAAA;EAAA,SAC9C,KAAA,GAAQ,IAAA,aAAiB,MAAA,CAAO,MAAA,OAAa,YAAA;EAAA,SAC7C,IAAA,GACP,IAAA,aACG,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,SAAA,GAAY,YAAA;EAAA,SACpC,MAAA,GAAS,IAAA,aAAiB,MAAA,CAAO,MAAA,UAAgB,YAAA;AAAA;;;;;;;KAahD,aAAA;EAAA,SACD,GAAA;EAAA,SACA,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,YAAA;EAAA,SACjC,IAAA,EAAM,MAAA,CAAO,MAAA,OAAa,YAAA;EAAA,SAC1B,IAAA,EAAM,MAAA,CAAO,MAAA;IAAA,SAAkB,QAAA;EAAA,GAAoB,YAAA;AAAA;AAtF9D;;;;;;;;AAAA,KAqGY,eAAA;EAAA,SACD,EAAA,EAAI,SAAA;EAAA,SACJ,IAAA,GACP,OAAA,EAAS,iBAAA,KACN,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,YAAA;EAAA,SACtB,UAAA,GACP,OAAA,EAAS,iBAAA,KACN,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,YAAA;EArGrB;;;;;;EAAA,SA4GA,KAAA,GACP,OAAA,EAAS,kBAAA,KACN,MAAA,CAAO,MAAA,CAAO,aAAA,EAAe,YAAA,EAA2B,KAAA,CAAM,KAAA;EAAA,SAC1D,KAAA,EAAO,iBAAA;AAAA;AAAA,KAON,mBAAA;EAAA,SACD,MAAA,GACP,IAAA,EAAM,eAAA,EACN,IAAA,cACG,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,YAAA;EAAA,SACtB,OAAA,GAAU,EAAA,EAAI,UAAA,KAAe,MAAA,CAAO,MAAA,OAAa,YAAA;EAAA,SACjD,IAAA,EAAM,MAAA,CAAO,MAAA,CACpB,aAAA;IAAA,SAAyB,EAAA,EAAI,UAAA;IAAA,SAAqB,IAAA;EAAA,IAClD,YAAA;AAAA;AAAA,KAIQ,iBAAA;EAAA,SACD,MAAA,GACP,IAAA,UACA,OAAA;IAAA,SAAqB,UAAA;EAAA,MAClB,MAAA,CAAO,MAAA,CAAO,QAAA,EAAU,YAAA;EAAA,SACpB,OAAA,GAAU,EAAA,EAAI,QAAA,KAAa,MAAA,CAAO,MAAA,OAAa,YAAA;EAAA,SAC/C,IAAA,EAAM,MAAA,CAAO,MAAA,CACpB,aAAA;IAAA,SAAyB,EAAA,EAAI,QAAA;IAAA,SAAmB,IAAA;EAAA,IAChD,YAAA;AAAA;AAAA,KAIQ,eAAA;EA5HqD;;AAGjE;;;;EAHiE,SAmItD,MAAA,GACP,QAAA,EAAU,eAAA,EACV,IAAA,aACG,MAAA,CAAO,MAAA;IAAA,SAAkB,GAAA;EAAA,GAAe,YAAA;AAAA;;;AAxH/C;;;;;;;;;;;;;;;;KAiJY,cAAA;EA9IW;;;;AAGvB;;EAHuB,SAqJZ,MAAA,GACP,OAAA,EAAS,mBAAA,KACN,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,YAAA,EAA2B,KAAA,CAAM,KAAA;EAzJ3C;;;;;;EAAA,SAiKjB,MAAA,GACP,EAAA,EAAI,SAAA,KACD,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,YAAA,EAA2B,KAAA,CAAM,KAAA;;;;WAK5D,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,UAAA,GAAa,YAAA;;;;;WAM/C,OAAA,GAAU,EAAA,EAAI,SAAA,KAAc,MAAA,CAAO,MAAA,OAAa,YAAA;WAGhD,SAAA,EAAW,mBAAA,EAhLM;EAAA,SAmLjB,OAAA,EAAS,iBAAA;WAGT,KAAA,EAAO,eAAA;AAAA;AAAA,cACjB,YAAA;cAEY,OAAA,SAAgB,YAAA;AAAA,cAEzB,6BAAA;;;;;;;;;;;cAgBS,wBAAA,SAAiC,6BAAA;AAAA,cAE1C,2BAAA;;;;;;;;;cAUS,sBAAA,SAA+B,2BAAA;AAAA,cAExC,qBAAA;;;;;;;cAQS,gBAAA,SAAyB,qBAAA;AAAA,cAElC,uBAAA;;;;;;;cAQS,kBAAA,SAA2B,uBAAA;AAAA,cAEpC,mBAAA;;;;;;;;;cAUS,cAAA,SAAuB,mBAAA;AAAA,cAEhC,yBAAA;;;;;;;;;;;;cAaS,oBAAA,SAA6B,yBAAA;AAAA,cAEtC,eAAA;;;;;;cAOS,UAAA,SAAmB,eAAA;AAAA,cAE5B,uBAAA;;;;;;;cAQS,kBAAA,SAA2B,uBAAA;AAAA,cAEpC,wBAAA;;;;;;;;cASS,mBAAA,SAA4B,wBAAA;;;;;cAY5B,MAAA,GACX,OAAA,EAAS,mBAAA,KACR,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,YAAA,EAA2B,OAAA,GAAU,KAAA,CAAM,KAAA;;;;;cAOhE,MAAA,GACX,EAAA,EAAI,SAAA,KACH,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,YAAA,EAA2B,OAAA,GAAU,KAAA,CAAM,KAAA;;cAIhE,IAAA,EAAM,MAAA,CAAO,MAAA,CACxB,aAAA,CAAc,UAAA,GACd,YAAA,EACA,OAAA;;;;;;cAQW,OAAA,GAAW,EAAA,EAAI,SAAA,KAAY,MAAA,CAAO,MAAA,OAAa,YAAA,EAA2B,OAAA;;;;;AAhUvF;;cAyUa,QAAA,GACX,IAAA,EAAM,eAAA,EACN,IAAA,cACC,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,YAAA,EAA2B,OAAA,GAAU,gBAAA;;;AA1UlE;cAoVa,YAAA,GACX,IAAA,UACA,OAAA;EAAA,SAAqB,UAAA;AAAA,MACpB,MAAA,CAAO,MAAA,CAAO,QAAA,EAAU,YAAA,EAA2B,OAAA,GAAU,cAAA;;cAQnD,aAAA,GACX,EAAA,EAAI,QAAA,KACH,MAAA,CAAO,MAAA,OAAa,YAAA,EAA2B,OAAA,GAAU,cAAA;;cAQ/C,WAAA,EAAa,MAAA,CAAO,MAAA,CAC/B,aAAA;EAAA,SAAyB,EAAA,EAAI,QAAA;EAAA,SAAmB,IAAA;AAAA,IAChD,YAAA,EACA,OAAA,GAAU,cAAA;;cAQC,eAAA,GACX,EAAA,EAAI,UAAA,KACH,MAAA,CAAO,MAAA,OAAa,YAAA,EAA2B,OAAA,GAAU,gBAAA;;cAQ/C,aAAA,EAAe,MAAA,CAAO,MAAA,CACjC,aAAA;EAAA,SAAyB,EAAA,EAAI,UAAA;EAAA,SAAqB,IAAA;AAAA,IAClD,YAAA,EACA,OAAA,GAAU,gBAAA;;;;;;;;cAcC,UAAA,GACX,QAAA,EAAU,eAAA,EACV,IAAA,aACC,MAAA,CAAO,MAAA;EAAA,SACG,GAAA;AAAA,GACX,YAAA,EACA,OAAA,GAAU,mBAAA"}

package/dist/sandbox/Sandbox.mjs

@@ -0,0 +1,192 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Brand, Context, Data, Effect } from "effect";
+//#region src/sandbox/Sandbox.ts
+var Sandbox_exports = /* @__PURE__ */ __exportAll({
+	ExecEvent: () => ExecEvent,
+	ImageRef: () => ImageRef,
+	NetworkPolicy: () => NetworkPolicy,
+	Sandbox: () => Sandbox,
+	SandboxCustomImage: () => SandboxCustomImage,
+	SandboxHostnameAllowlist: () => SandboxHostnameAllowlist,
+	SandboxId: () => SandboxId,
+	SandboxKernelSession: () => SandboxKernelSession,
+	SandboxPauseResume: () => SandboxPauseResume,
+	SandboxPortExposure: () => SandboxPortExposure,
+	SandboxPty: () => SandboxPty,
+	SandboxSecretInjection: () => SandboxSecretInjection,
+	SandboxSnapshots: () => SandboxSnapshots,
+	SandboxVolumes: () => SandboxVolumes,
+	SnapshotId: () => SnapshotId,
+	VolumeId: () => VolumeId,
+	attach: () => attach,
+	create: () => create,
+	createVolume: () => createVolume,
+	destroy: () => destroy,
+	destroySnapshot: () => destroySnapshot,
+	destroyVolume: () => destroyVolume,
+	exposePort: () => exposePort,
+	list: () => list,
+	listSnapshots: () => listSnapshots,
+	listVolumes: () => listVolumes,
+	snapshot: () => snapshot
+});
+const SandboxId = Brand.nominal();
+const VolumeId = Brand.nominal();
+const SnapshotId = Brand.nominal();
+const ImageRef = Data.taggedEnum();
+const NetworkPolicy = Data.taggedEnum();
+const ExecEvent = Data.taggedEnum();
+var Sandbox = class extends Context.Service()("@betalyra/effect-uai/Sandbox") {};
+/**
+* Capability marker — provided by adapter Layers whose provider
+* supports a hostname-level egress allowlist (matching against host
+* names / wildcards, not just CIDRs). Vercel, Cloudflare, Deno,
+* Microsandbox, Runloop, Anthropic srt ship this marker; Modal and
+* Daytona (CIDR-only) do not.
+*
+* Phantom — the value is `void`; adapters register with
+* `Layer.succeed(SandboxHostnameAllowlist, undefined)`.
+*/
+var SandboxHostnameAllowlist = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxHostnameAllowlist") {};
+/**
+* Capability marker — adapter's provider supports proxy-layer
+* secret rewriting (header injection on outbound HTTPS to bound
+* hosts; the running code never sees the real value). Deno,
+* Cloudflare, E2B, Vercel (firewall transform), Microsandbox,
+* Runloop (Agent Gateway) ship this. Modal, Daytona, CodeSandbox
+* do not.
+*/
+var SandboxSecretInjection = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxSecretInjection") {};
+/**
+* Capability marker — adapter supports snapshot-as-new-sandbox
+* (capture state, restore as a derived sandbox with a fresh id).
+* Distinct from {@link SandboxPauseResume}, which preserves the
+* same id and resumes in place.
+*/
+var SandboxSnapshots = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxSnapshots") {};
+/**
+* Capability marker — adapter supports in-place pause and resume on
+* the same sandbox id (E2B, CodeSandbox). Memory + processes are
+* preserved across the pause boundary. Most providers without this
+* marker offer {@link SandboxSnapshots} instead.
+*/
+var SandboxPauseResume = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxPauseResume") {};
+/**
+* Capability marker — adapter manages named persistent volumes
+* outside any single sandbox lifecycle (Modal Volume, Daytona,
+* Microsandbox, BoxLite). Providers without this marker leave
+* `Sandbox.volumes.*` returning `SandboxUnsupported`; the free
+* helpers ({@link createVolume}, {@link destroyVolume}) additionally
+* require this marker on R so misuses become a type error.
+*/
+var SandboxVolumes = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxVolumes") {};
+/**
+* Capability marker — adapter supports a stateful kernel session
+* (Jupyter-style: persistent Python / JS context that returns rich
+* outputs across many `runCode` calls). Cloudflare Code Interpreter
+* and E2B ship this; everyone else expects you to write your own
+* script and `exec` it.
+*
+* The actual `runCode` helper lives separately (not on
+* `SandboxInstance`) because the return shape is different — rich
+* outputs with images/tables, not buffered stdout strings.
+*/
+var SandboxKernelSession = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxKernelSession") {};
+/**
+* Capability marker — adapter exposes an interactive PTY session
+* (Runloop, Cloudflare terminal). Distinct from `execStream` which
+* is byte-oriented and one-shot.
+*/
+var SandboxPty = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxPty") {};
+/**
+* Capability marker — adapter accepts a user-supplied Dockerfile (or
+* OCI image build) instead of just a registry reference. Vercel does
+* not ship this (fixed AL2023). Deno does not (snapshots only).
+* Most others do.
+*/
+var SandboxCustomImage = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxCustomImage") {};
+/**
+* Capability marker — adapter can expose an internal port as a
+* publicly reachable URL. Most cloud providers ship this; local
+* providers (Microsandbox, BoxLite) typically only support
+* host-side port forwarding (handled by ignoring this marker and
+* documenting via the per-provider request type).
+*/
+var SandboxPortExposure = class extends Context.Service()("@betalyra/effect-uai/capability/SandboxPortExposure") {};
+/**
+* Provision a sandbox bound to the caller's scope. Drop the
+* `Scope.Scope` requirement with `Effect.scoped`.
+*/
+const create = (request) => Effect.flatMap(Sandbox.asEffect(), (s) => s.create(request));
+/**
+* Re-acquire an existing sandbox by id. Same scope semantics as
+* `create`, but the finalizer detaches rather than destroying.
+*/
+const attach = (id) => Effect.flatMap(Sandbox.asEffect(), (s) => s.attach(id));
+/** Enumerate sandboxes for the configured account / project. */
+const list = Effect.flatMap(Sandbox.asEffect(), (s) => s.list);
+/**
+* Escape hatch for destroying a sandbox from outside its owning
+* scope. Most callers should let the scope finalizer handle this
+* automatically.
+*/
+const destroy = (id) => Effect.flatMap(Sandbox.asEffect(), (s) => s.destroy(id));
+/**
+* Create a snapshot of a live sandbox. Requires
+* {@link SandboxSnapshots} on the R channel — adapters whose
+* provider doesn't support snapshot-as-new-sandbox don't ship the
+* marker and calls fail at `Effect.provide` with a type error.
+*/
+const snapshot = (from, name) => Effect.gen(function* () {
+	const s = yield* Sandbox.asEffect();
+	yield* SandboxSnapshots.asEffect();
+	return yield* s.snapshots.create(from, name);
+});
+/**
+* Create a named persistent volume. Requires {@link SandboxVolumes}.
+*/
+const createVolume = (name, options) => Effect.gen(function* () {
+	const s = yield* Sandbox.asEffect();
+	yield* SandboxVolumes.asEffect();
+	return yield* s.volumes.create(name, options);
+});
+/** Destroy a named volume. Requires {@link SandboxVolumes}. */
+const destroyVolume = (id) => Effect.gen(function* () {
+	const s = yield* Sandbox.asEffect();
+	yield* SandboxVolumes.asEffect();
+	return yield* s.volumes.destroy(id);
+});
+/** Enumerate persistent volumes. Requires {@link SandboxVolumes}. */
+const listVolumes = Effect.gen(function* () {
+	const s = yield* Sandbox.asEffect();
+	yield* SandboxVolumes.asEffect();
+	return yield* s.volumes.list;
+});
+/** Destroy a snapshot. Requires {@link SandboxSnapshots}. */
+const destroySnapshot = (id) => Effect.gen(function* () {
+	const s = yield* Sandbox.asEffect();
+	yield* SandboxSnapshots.asEffect();
+	return yield* s.snapshots.destroy(id);
+});
+/** Enumerate snapshots. Requires {@link SandboxSnapshots}. */
+const listSnapshots = Effect.gen(function* () {
+	const s = yield* Sandbox.asEffect();
+	yield* SandboxSnapshots.asEffect();
+	return yield* s.snapshots.list;
+});
+/**
+* Expose an internal port of a live sandbox as a publicly reachable
+* URL. Requires {@link SandboxPortExposure} — adapters whose provider
+* doesn't support runtime port exposure (e.g. Microsandbox, which
+* forwards at create time only) don't ship the marker, and calls
+* fail at `Effect.provide` with a type error.
+*/
+const exposePort = (instance, port) => Effect.gen(function* () {
+	const s = yield* Sandbox.asEffect();
+	yield* SandboxPortExposure.asEffect();
+	return yield* s.ports.expose(instance, port);
+});
+//#endregion
+export { ExecEvent, ImageRef, NetworkPolicy, Sandbox, SandboxCustomImage, SandboxHostnameAllowlist, SandboxId, SandboxKernelSession, SandboxPauseResume, SandboxPortExposure, SandboxPty, SandboxSecretInjection, SandboxSnapshots, SandboxVolumes, SnapshotId, VolumeId, attach, create, createVolume, destroy, destroySnapshot, destroyVolume, exposePort, list, listSnapshots, listVolumes, snapshot, Sandbox_exports as t };
+
+//# sourceMappingURL=Sandbox.mjs.map

package/dist/sandbox/Sandbox.mjs.map

@@ -0,0 +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.asEffect(), (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.asEffect(), (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.asEffect(), (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.asEffect(), (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.asEffect()\n    yield* SandboxSnapshots.asEffect()\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.asEffect()\n    yield* SandboxVolumes.asEffect()\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.asEffect()\n    yield* SandboxVolumes.asEffect()\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.asEffect()\n  yield* SandboxVolumes.asEffect()\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.asEffect()\n    yield* SandboxSnapshots.asEffect()\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.asEffect()\n  yield* SandboxSnapshots.asEffect()\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.asEffect()\n    yield* SandboxPortExposure.asEffect()\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,QAAQ,UAAU,GAAG,MAAM,EAAE,OAAO,QAAQ,CAAC;;;;;AAM9D,MAAa,UACX,OAEA,OAAO,QAAQ,QAAQ,UAAU,GAAG,MAAM,EAAE,OAAO,GAAG,CAAC;;AAGzD,MAAa,OAIT,OAAO,QAAQ,QAAQ,UAAU,GAAG,MAAM,EAAE,KAAK;;;;;;AAOrD,MAAa,WAAW,OACtB,OAAO,QAAQ,QAAQ,UAAU,GAAG,MAAM,EAAE,QAAQ,GAAG,CAAC;;;;;;;AAQ1D,MAAa,YACX,MACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,QAAQ,UAAU;AACnC,QAAO,iBAAiB,UAAU;AAClC,QAAO,OAAO,EAAE,UAAU,OAAO,MAAM,KAAK;EAC5C;;;;AAKJ,MAAa,gBACX,MACA,YAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,QAAQ,UAAU;AACnC,QAAO,eAAe,UAAU;AAChC,QAAO,OAAO,EAAE,QAAQ,OAAO,MAAM,QAAQ;EAC7C;;AAGJ,MAAa,iBACX,OAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,QAAQ,UAAU;AACnC,QAAO,eAAe,UAAU;AAChC,QAAO,OAAO,EAAE,QAAQ,QAAQ,GAAG;EACnC;;AAGJ,MAAa,cAIT,OAAO,IAAI,aAAa;CAC1B,MAAM,IAAI,OAAO,QAAQ,UAAU;AACnC,QAAO,eAAe,UAAU;AAChC,QAAO,OAAO,EAAE,QAAQ;EACxB;;AAGF,MAAa,mBACX,OAEA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,QAAQ,UAAU;AACnC,QAAO,iBAAiB,UAAU;AAClC,QAAO,OAAO,EAAE,UAAU,QAAQ,GAAG;EACrC;;AAGJ,MAAa,gBAIT,OAAO,IAAI,aAAa;CAC1B,MAAM,IAAI,OAAO,QAAQ,UAAU;AACnC,QAAO,iBAAiB,UAAU;AAClC,QAAO,OAAO,EAAE,UAAU;EAC1B;;;;;;;;AASF,MAAa,cACX,UACA,SAMA,OAAO,IAAI,aAAa;CACtB,MAAM,IAAI,OAAO,QAAQ,UAAU;AACnC,QAAO,oBAAoB,UAAU;AACrC,QAAO,OAAO,EAAE,MAAM,OAAO,UAAU,KAAK;EAC5C"}

package/dist/sandbox/SandboxError.d.mts

@@ -0,0 +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-BvKypkJm.mjs";
+export { SandboxAlreadyExists, SandboxAuthFailed, SandboxAuthSubtype, SandboxCreateFailed, SandboxError, SandboxExecFailed, SandboxInvalidRequest, SandboxNetworkPolicyDenied, SandboxNotFound, SandboxQuotaExceeded, SandboxTimeout, SandboxUnsupported };

package/dist/sandbox/SandboxError.mjs

@@ -0,0 +1,89 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Data } from "effect";
+//#region src/sandbox/SandboxError.ts
+var SandboxError_exports = /* @__PURE__ */ __exportAll({
+	SandboxAlreadyExists: () => SandboxAlreadyExists,
+	SandboxAuthFailed: () => SandboxAuthFailed,
+	SandboxCreateFailed: () => SandboxCreateFailed,
+	SandboxExecFailed: () => SandboxExecFailed,
+	SandboxInvalidRequest: () => SandboxInvalidRequest,
+	SandboxNetworkPolicyDenied: () => SandboxNetworkPolicyDenied,
+	SandboxNotFound: () => SandboxNotFound,
+	SandboxQuotaExceeded: () => SandboxQuotaExceeded,
+	SandboxTimeout: () => SandboxTimeout,
+	SandboxUnsupported: () => SandboxUnsupported
+});
+/**
+* Failed to provision a sandbox. Covers image pull failures, region
+* unavailability, the provider being unreachable, etc. The provider's
+* structured reason (if any) is on `reason`; the raw error from the
+* underlying SDK is on `raw`.
+*/
+var SandboxCreateFailed = class extends Data.TaggedError("SandboxCreateFailed") {};
+/**
+* The requested sandbox id does not exist (or was already destroyed).
+* Distinct from `SandboxCreateFailed` — this is for `attach` / `destroy` /
+* `get`-style lookups against a stale id.
+*/
+var SandboxNotFound = class extends Data.TaggedError("SandboxNotFound") {};
+/**
+* Caller tried to create a sandbox whose id is already taken. Providers
+* that keyed by name (Microsandbox, Modal) surface this when a previous
+* sandbox with the same name is still alive. Distinct from
+* `SandboxCreateFailed` so callers can retry with `replace` semantics.
+*/
+var SandboxAlreadyExists = class extends Data.TaggedError("SandboxAlreadyExists") {};
+/**
+* A shell exec inside the sandbox failed at the transport / SDK layer —
+* i.e. the SDK couldn't deliver the command to the guest, or the guest
+* agent itself errored. A non-zero exit code from the guest's command
+* is NOT an error; it's an `ExecResult` with `exitCode !== 0`.
+*/
+var SandboxExecFailed = class extends Data.TaggedError("SandboxExecFailed") {};
+/**
+* A sandbox operation (create, exec, file op) exceeded its time budget.
+* Carries the budget that was breached for observability.
+*/
+var SandboxTimeout = class extends Data.TaggedError("SandboxTimeout") {};
+/**
+* Outbound network request from inside the sandbox was blocked by the
+* configured egress policy (host not on allowlist, CIDR mismatch, etc.).
+* Surfaced when the provider's SDK reports the denial back to the host
+* — many providers simply let the request fail inside the guest and
+* never report this to the host, in which case this error is never
+* raised by the adapter.
+*/
+var SandboxNetworkPolicyDenied = class extends Data.TaggedError("SandboxNetworkPolicyDenied") {};
+/**
+* Provider rejected the create / exec because account / org / project
+* quota or concurrency limit was exceeded. Surfaced separately from
+* `SandboxCreateFailed` so callers can back off and retry intelligently.
+*/
+var SandboxQuotaExceeded = class extends Data.TaggedError("SandboxQuotaExceeded") {};
+/**
+* Caller's request shape is malformed for the wired provider — e.g. a
+* Dockerfile passed to a provider that only accepts registry refs, a
+* hostname allowlist passed to a CIDR-only provider, etc. Adapters
+* should also reject these at the request-schema layer where possible;
+* this is the runtime fallback.
+*/
+var SandboxInvalidRequest = class extends Data.TaggedError("SandboxInvalidRequest") {};
+var SandboxAuthFailed = class extends Data.TaggedError("SandboxAuthFailed") {};
+/**
+* The wired provider does not implement the requested capability for
+* this specific request. Distinct from `SandboxInvalidRequest` (the
+* request shape is malformed) and from compile-time capability
+* markers (`SandboxSnapshots`, `SandboxSecretInjection`, …) which gate
+* blanket provider-level gaps.
+*
+* Reserved for request-data-dependent gaps where the provider supports
+* the method in general but not for these inputs — e.g. passing
+* `hosts: [...]` to a CIDR-only allowlist provider, or passing
+* `dockerfile: ...` to a provider whose `SandboxCustomImage` marker
+* was provided but which only accepts a flat Dockerfile string.
+*/
+var SandboxUnsupported = class extends Data.TaggedError("SandboxUnsupported") {};
+//#endregion
+export { SandboxAlreadyExists, SandboxAuthFailed, SandboxCreateFailed, SandboxExecFailed, SandboxInvalidRequest, SandboxNetworkPolicyDenied, SandboxNotFound, SandboxQuotaExceeded, SandboxTimeout, SandboxUnsupported, SandboxError_exports as t };
+
+//# sourceMappingURL=SandboxError.mjs.map

package/dist/sandbox/SandboxError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxError.mjs","names":[],"sources":["../../src/sandbox/SandboxError.ts"],"sourcesContent":["import { Data, Duration } from \"effect\"\n\n/**\n * Failed to provision a sandbox. Covers image pull failures, region\n * unavailability, the provider being unreachable, etc. The provider's\n * structured reason (if any) is on `reason`; the raw error from the\n * underlying SDK is on `raw`.\n */\nexport class SandboxCreateFailed extends Data.TaggedError(\"SandboxCreateFailed\")<{\n  provider: string\n  reason?: string\n  raw: unknown\n}> {}\n\n/**\n * The requested sandbox id does not exist (or was already destroyed).\n * Distinct from `SandboxCreateFailed` — this is for `attach` / `destroy` /\n * `get`-style lookups against a stale id.\n */\nexport class SandboxNotFound extends Data.TaggedError(\"SandboxNotFound\")<{\n  provider: string\n  id: string\n}> {}\n\n/**\n * Caller tried to create a sandbox whose id is already taken. Providers\n * that keyed by name (Microsandbox, Modal) surface this when a previous\n * sandbox with the same name is still alive. Distinct from\n * `SandboxCreateFailed` so callers can retry with `replace` semantics.\n */\nexport class SandboxAlreadyExists extends Data.TaggedError(\"SandboxAlreadyExists\")<{\n  provider: string\n  id: string\n}> {}\n\n/**\n * A shell exec inside the sandbox failed at the transport / SDK layer —\n * i.e. the SDK couldn't deliver the command to the guest, or the guest\n * agent itself errored. A non-zero exit code from the guest's command\n * is NOT an error; it's an `ExecResult` with `exitCode !== 0`.\n */\nexport class SandboxExecFailed extends Data.TaggedError(\"SandboxExecFailed\")<{\n  provider: string\n  reason?: string\n  raw: unknown\n}> {}\n\n/**\n * A sandbox operation (create, exec, file op) exceeded its time budget.\n * Carries the budget that was breached for observability.\n */\nexport class SandboxTimeout extends Data.TaggedError(\"SandboxTimeout\")<{\n  provider: string\n  operation: \"create\" | \"exec\" | \"filesystem\" | \"attach\"\n  budget?: Duration.Duration\n  raw?: unknown\n}> {}\n\n/**\n * Outbound network request from inside the sandbox was blocked by the\n * configured egress policy (host not on allowlist, CIDR mismatch, etc.).\n * Surfaced when the provider's SDK reports the denial back to the host\n * — many providers simply let the request fail inside the guest and\n * never report this to the host, in which case this error is never\n * raised by the adapter.\n */\nexport class SandboxNetworkPolicyDenied extends Data.TaggedError(\"SandboxNetworkPolicyDenied\")<{\n  provider: string\n  host?: string\n  reason?: string\n  raw: unknown\n}> {}\n\n/**\n * Provider rejected the create / exec because account / org / project\n * quota or concurrency limit was exceeded. Surfaced separately from\n * `SandboxCreateFailed` so callers can back off and retry intelligently.\n */\nexport class SandboxQuotaExceeded extends Data.TaggedError(\"SandboxQuotaExceeded\")<{\n  provider: string\n  reason?: string\n  raw: unknown\n}> {}\n\n/**\n * Caller's request shape is malformed for the wired provider — e.g. a\n * Dockerfile passed to a provider that only accepts registry refs, a\n * hostname allowlist passed to a CIDR-only provider, etc. Adapters\n * should also reject these at the request-schema layer where possible;\n * this is the runtime fallback.\n */\nexport class SandboxInvalidRequest extends Data.TaggedError(\"SandboxInvalidRequest\")<{\n  provider: string\n  param?: string\n  reason?: string\n  raw?: unknown\n}> {}\n\n/**\n * Sandbox SDK could not authenticate against the provider. Subtype\n * mirrors the model-side `AiError.AuthFailed` shape for consistency.\n */\nexport type SandboxAuthSubtype = \"auth\" | \"permission\" | \"billing\" | \"quota\"\n\nexport class SandboxAuthFailed extends Data.TaggedError(\"SandboxAuthFailed\")<{\n  provider: string\n  subtype: SandboxAuthSubtype\n  raw: unknown\n}> {}\n\n/**\n * The wired provider does not implement the requested capability for\n * this specific request. Distinct from `SandboxInvalidRequest` (the\n * request shape is malformed) and from compile-time capability\n * markers (`SandboxSnapshots`, `SandboxSecretInjection`, …) which gate\n * blanket provider-level gaps.\n *\n * Reserved for request-data-dependent gaps where the provider supports\n * the method in general but not for these inputs — e.g. passing\n * `hosts: [...]` to a CIDR-only allowlist provider, or passing\n * `dockerfile: ...` to a provider whose `SandboxCustomImage` marker\n * was provided but which only accepts a flat Dockerfile string.\n */\nexport class SandboxUnsupported extends Data.TaggedError(\"SandboxUnsupported\")<{\n  provider: string\n  capability: string\n  reason?: string\n}> {}\n\nexport type SandboxError =\n  | SandboxCreateFailed\n  | SandboxNotFound\n  | SandboxAlreadyExists\n  | SandboxExecFailed\n  | SandboxTimeout\n  | SandboxNetworkPolicyDenied\n  | SandboxQuotaExceeded\n  | SandboxInvalidRequest\n  | SandboxAuthFailed\n  | SandboxUnsupported\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAQA,IAAa,sBAAb,cAAyC,KAAK,YAAY,sBAAsB,CAI7E;;;;;;AAOH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAGrE;;;;;;;AAQH,IAAa,uBAAb,cAA0C,KAAK,YAAY,uBAAuB,CAG/E;;;;;;;AAQH,IAAa,oBAAb,cAAuC,KAAK,YAAY,oBAAoB,CAIzE;;;;;AAMH,IAAa,iBAAb,cAAoC,KAAK,YAAY,iBAAiB,CAKnE;;;;;;;;;AAUH,IAAa,6BAAb,cAAgD,KAAK,YAAY,6BAA6B,CAK3F;;;;;;AAOH,IAAa,uBAAb,cAA0C,KAAK,YAAY,uBAAuB,CAI/E;;;;;;;;AASH,IAAa,wBAAb,cAA2C,KAAK,YAAY,wBAAwB,CAKjF;AAQH,IAAa,oBAAb,cAAuC,KAAK,YAAY,oBAAoB,CAIzE;;;;;;;;;;;;;;AAeH,IAAa,qBAAb,cAAwC,KAAK,YAAY,qBAAqB,CAI3E"}

package/dist/sandbox/SandboxImage.d.mts

@@ -0,0 +1,28 @@
+import { ImageRef, SnapshotId } from "./Sandbox.mjs";
+
+//#region src/sandbox/SandboxImage.d.ts
+declare namespace SandboxImage_d_exports {
+  export { auto, dockerfile, registry, snapshot };
+}
+/**
+ * Ergonomic constructors for {@link ImageRef}. `ImageRef.*` tagged
+ * constructors still exist (and are what pattern-matching code uses);
+ * these helpers are what end users reach for at the call site.
+ *
+ * @example
+ * ```ts
+ * import * as Image from "@effect-uai/core/SandboxImage"
+ *
+ * Image.auto                         // provider's house image
+ * Image.registry("python:3.12")      // OCI registry ref
+ * Image.snapshot("ml-warm-1")        // restore captured state (gated)
+ * Image.dockerfile("FROM ubuntu...") // build custom (gated)
+ * ```
+ */
+declare const auto: ImageRef;
+declare const registry: (ref: string) => ImageRef;
+declare const snapshot: (id: SnapshotId | string) => ImageRef;
+declare const dockerfile: (contents: string) => ImageRef;
+//#endregion
+export { auto, dockerfile, registry, snapshot, SandboxImage_d_exports as t };
+//# sourceMappingURL=SandboxImage.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxImage.d.mts","names":[],"sources":["../../src/sandbox/SandboxImage.ts"],"mappings":";;;;;;;;;;;;;;;AAkBA;;;;;AAEA;cAFa,IAAA,EAAM,QAAA;AAAA,cAEN,QAAA,GAAY,GAAA,aAAc,QAAA;AAAA,cAE1B,QAAA,GAAY,EAAA,EAAI,UAAA,cAAsB,QAAA;AAAA,cAGtC,UAAA,GAAc,QAAA,aAAmB,QAAA"}

package/dist/sandbox/SandboxImage.mjs

@@ -0,0 +1,32 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { ImageRef, SnapshotId } from "./Sandbox.mjs";
+//#region src/sandbox/SandboxImage.ts
+var SandboxImage_exports = /* @__PURE__ */ __exportAll({
+	auto: () => auto,
+	dockerfile: () => dockerfile,
+	registry: () => registry,
+	snapshot: () => snapshot
+});
+/**
+* Ergonomic constructors for {@link ImageRef}. `ImageRef.*` tagged
+* constructors still exist (and are what pattern-matching code uses);
+* these helpers are what end users reach for at the call site.
+*
+* @example
+* ```ts
+* import * as Image from "@effect-uai/core/SandboxImage"
+*
+* Image.auto                         // provider's house image
+* Image.registry("python:3.12")      // OCI registry ref
+* Image.snapshot("ml-warm-1")        // restore captured state (gated)
+* Image.dockerfile("FROM ubuntu...") // build custom (gated)
+* ```
+*/
+const auto = ImageRef.Default();
+const registry = (ref) => ImageRef.Registry({ ref });
+const snapshot = (id) => ImageRef.Snapshot({ id: SnapshotId(id) });
+const dockerfile = (contents) => ImageRef.Dockerfile({ contents });
+//#endregion
+export { auto, dockerfile, registry, snapshot, SandboxImage_exports as t };
+
+//# sourceMappingURL=SandboxImage.mjs.map

package/dist/sandbox/SandboxImage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxImage.mjs","names":[],"sources":["../../src/sandbox/SandboxImage.ts"],"sourcesContent":["import { ImageRef, SnapshotId } from \"./Sandbox.js\"\n\n/**\n * Ergonomic constructors for {@link ImageRef}. `ImageRef.*` tagged\n * constructors still exist (and are what pattern-matching code uses);\n * these helpers are what end users reach for at the call site.\n *\n * @example\n * ```ts\n * import * as Image from \"@effect-uai/core/SandboxImage\"\n *\n * Image.auto                         // provider's house image\n * Image.registry(\"python:3.12\")      // OCI registry ref\n * Image.snapshot(\"ml-warm-1\")        // restore captured state (gated)\n * Image.dockerfile(\"FROM ubuntu...\") // build custom (gated)\n * ```\n */\n\nexport const auto: ImageRef = ImageRef.Default()\n\nexport const registry = (ref: string): ImageRef => ImageRef.Registry({ ref })\n\nexport const snapshot = (id: SnapshotId | string): ImageRef =>\n  ImageRef.Snapshot({ id: SnapshotId(id) })\n\nexport const dockerfile = (contents: string): ImageRef => ImageRef.Dockerfile({ contents })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAkBA,MAAa,OAAiB,SAAS,SAAS;AAEhD,MAAa,YAAY,QAA0B,SAAS,SAAS,EAAE,KAAK,CAAC;AAE7E,MAAa,YAAY,OACvB,SAAS,SAAS,EAAE,IAAI,WAAW,GAAG,EAAE,CAAC;AAE3C,MAAa,cAAc,aAA+B,SAAS,WAAW,EAAE,UAAU,CAAC"}

package/dist/sandbox/SandboxNetwork.d.mts

@@ -0,0 +1,34 @@
+import { NetworkPolicy } from "./Sandbox.mjs";
+
+//#region src/sandbox/SandboxNetwork.d.ts
+declare namespace SandboxNetwork_d_exports {
+  export { allow, allowCidrs, allowHosts, blocked, open };
+}
+/**
+ * Ergonomic constructors for {@link NetworkPolicy}. The tagged
+ * constructors under `Sandbox.NetworkPolicy.*` still exist (and are
+ * what pattern-matching code uses); these helpers are what end users
+ * reach for at the call site.
+ *
+ * @example
+ * ```ts
+ * import * as Network from "@effect-uai/core/SandboxNetwork"
+ *
+ * Network.open                                    // provider defaults apply
+ * Network.blocked                                 // airgapped — no egress
+ * Network.allowHosts("api.openai.com", "github.com")
+ * Network.allowCidrs("10.0.0.0/8")
+ * Network.allow({ hosts: [...], cidrs: [...] })   // combined allowlist
+ * ```
+ */
+declare const open: NetworkPolicy;
+declare const blocked: NetworkPolicy;
+declare const allowHosts: (...hosts: ReadonlyArray<string>) => NetworkPolicy;
+declare const allowCidrs: (...cidrs: ReadonlyArray<string>) => NetworkPolicy;
+declare const allow: (opts: {
+  readonly hosts?: ReadonlyArray<string>;
+  readonly cidrs?: ReadonlyArray<string>;
+}) => NetworkPolicy;
+//#endregion
+export { allow, allowCidrs, allowHosts, blocked, open, SandboxNetwork_d_exports as t };
+//# sourceMappingURL=SandboxNetwork.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxNetwork.d.mts","names":[],"sources":["../../src/sandbox/SandboxNetwork.ts"],"mappings":";;;;;;;;;;;;;;;;AAoBA;;;;;AAEA;;cAFa,IAAA,EAAM,aAAA;AAAA,cAEN,OAAA,EAAS,aAAA;AAAA,cAET,UAAA,MAAiB,KAAA,EAAO,aAAA,aAAwB,aAAA;AAAA,cAGhD,UAAA,MAAiB,KAAA,EAAO,aAAA,aAAwB,aAAA;AAAA,cAGhD,KAAA,GAAS,IAAA;EAAA,SACX,KAAA,GAAQ,aAAA;EAAA,SACR,KAAA,GAAQ,aAAA;AAAA,MACf,aAAA"}

package/dist/sandbox/SandboxNetwork.mjs

@@ -0,0 +1,36 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { NetworkPolicy } from "./Sandbox.mjs";
+//#region src/sandbox/SandboxNetwork.ts
+var SandboxNetwork_exports = /* @__PURE__ */ __exportAll({
+	allow: () => allow,
+	allowCidrs: () => allowCidrs,
+	allowHosts: () => allowHosts,
+	blocked: () => blocked,
+	open: () => open
+});
+/**
+* Ergonomic constructors for {@link NetworkPolicy}. The tagged
+* constructors under `Sandbox.NetworkPolicy.*` still exist (and are
+* what pattern-matching code uses); these helpers are what end users
+* reach for at the call site.
+*
+* @example
+* ```ts
+* import * as Network from "@effect-uai/core/SandboxNetwork"
+*
+* Network.open                                    // provider defaults apply
+* Network.blocked                                 // airgapped — no egress
+* Network.allowHosts("api.openai.com", "github.com")
+* Network.allowCidrs("10.0.0.0/8")
+* Network.allow({ hosts: [...], cidrs: [...] })   // combined allowlist
+* ```
+*/
+const open = NetworkPolicy.Open();
+const blocked = NetworkPolicy.Blocked();
+const allowHosts = (...hosts) => NetworkPolicy.Allowlist({ hosts });
+const allowCidrs = (...cidrs) => NetworkPolicy.Allowlist({ cidrs });
+const allow = (opts) => NetworkPolicy.Allowlist(opts);
+//#endregion
+export { allow, allowCidrs, allowHosts, blocked, open, SandboxNetwork_exports as t };
+
+//# sourceMappingURL=SandboxNetwork.mjs.map

package/dist/sandbox/SandboxNetwork.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxNetwork.mjs","names":[],"sources":["../../src/sandbox/SandboxNetwork.ts"],"sourcesContent":["import { NetworkPolicy } from \"./Sandbox.js\"\n\n/**\n * Ergonomic constructors for {@link NetworkPolicy}. The tagged\n * constructors under `Sandbox.NetworkPolicy.*` still exist (and are\n * what pattern-matching code uses); these helpers are what end users\n * reach for at the call site.\n *\n * @example\n * ```ts\n * import * as Network from \"@effect-uai/core/SandboxNetwork\"\n *\n * Network.open                                    // provider defaults apply\n * Network.blocked                                 // airgapped — no egress\n * Network.allowHosts(\"api.openai.com\", \"github.com\")\n * Network.allowCidrs(\"10.0.0.0/8\")\n * Network.allow({ hosts: [...], cidrs: [...] })   // combined allowlist\n * ```\n */\n\nexport const open: NetworkPolicy = NetworkPolicy.Open()\n\nexport const blocked: NetworkPolicy = NetworkPolicy.Blocked()\n\nexport const allowHosts = (...hosts: ReadonlyArray<string>): NetworkPolicy =>\n  NetworkPolicy.Allowlist({ hosts })\n\nexport const allowCidrs = (...cidrs: ReadonlyArray<string>): NetworkPolicy =>\n  NetworkPolicy.Allowlist({ cidrs })\n\nexport const allow = (opts: {\n  readonly hosts?: ReadonlyArray<string>\n  readonly cidrs?: ReadonlyArray<string>\n}): NetworkPolicy => NetworkPolicy.Allowlist(opts)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,OAAsB,cAAc,MAAM;AAEvD,MAAa,UAAyB,cAAc,SAAS;AAE7D,MAAa,cAAc,GAAG,UAC5B,cAAc,UAAU,EAAE,OAAO,CAAC;AAEpC,MAAa,cAAc,GAAG,UAC5B,cAAc,UAAU,EAAE,OAAO,CAAC;AAEpC,MAAa,SAAS,SAGD,cAAc,UAAU,KAAK"}