@codeworksh/plugin 0.0.1-dev.20260922103030

package/sandbox/instance.mjs

@@ -0,0 +1,144 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { withStatics } from "../schema.mjs";
+import { Option, Schema } from "effect";
+import { uuidv7 } from "uuidv7";
+//#region src/sandbox/instance.ts
+var instance_exports = /* @__PURE__ */ __exportAll({
+	ID: () => ID,
+	Kind: () => Kind,
+	Ownership: () => Ownership,
+	PersistedError: () => PersistedError,
+	SandboxInstance: () => instance_exports,
+	Status: () => Status,
+	Usage: () => Usage,
+	fromColumn: () => fromColumn,
+	fromField: () => fromField,
+	isMountable: () => isMountable,
+	mountable: () => mountable,
+	toColumn: () => toColumn,
+	toField: () => toField
+});
+/**
+* A Sandbox instance is a **durable filesystem namespace** plus whatever compute
+* acts on it — a device in Unix terms, which exists whether or not anything has
+* it mounted. `Sandbox.Controller` is the only thing that creates,
+* stops, or destroys one; this module is just its identity and state model.
+*
+* The application ID is deliberately separate from the driver's own resource
+* locator: callers never parse a Vercel name or a Daytona ID, driver formats may
+* change, and a destroyed resource must stay identifiable in Project/Session
+* history. A missing resource is never recreated under an existing ID — a new
+* resource is a new namespace and therefore a new ID.
+*/
+const ID = Schema.String.pipe(Schema.brand("SandboxInstance.ID"), withStatics((schema) => ({
+	/**
+	* The host. Reserved, and never written to a column — see {@link toColumn}.
+	* It exists at runtime so nothing has to branch on "is this the host": it is
+	* what identity reads, what logs show, and what the transport cache keys on.
+	*/
+	local: schema.make("local"),
+	/** A fresh identity for a namespace nothing has named yet. */
+	create: () => schema.make(`sbx_${uuidv7()}`)
+})));
+/**
+* The storage boundary for namespace references, in one place.
+*
+* The host filesystem exists whether or not a row describes it, so it gets no
+* row and `NULL` is the only spelling of it — the Unix analogue is exact, since
+* `/` has no entry in the mount table you consult to find other mounts. That
+* makes a session or directory writable before any namespace is registered (the
+* foreign key is skipped on NULL), makes `SET sandbox_instance_id = NULL` a
+* meaningful "revert to the host", and leaves the host impossible to tombstone,
+* collect, or destroy, because there is nothing to point at.
+*
+* Two SQLite consequences ride on this and break correctness silently if missed:
+* unique indexes treat NULLs as distinct, so every uniqueness constraint
+* spanning a namespace column coalesces to `'local'`; and `= NULL` never
+* matches, so namespace-scoped reads use `IS`.
+*/
+const toColumn = (id) => id === ID.local ? null : id;
+const fromColumn = (value) => value === null ? ID.local : ID.make(value);
+/**
+* The same mapping for row models, whose optional columns are `Option` rather
+* than `null`. Kept beside {@link toColumn} so the boundary stays one place:
+* `toColumn`/`fromColumn` for SQL parameters, these for `Model.FieldOption`.
+*/
+const toField = (id) => id === ID.local ? Option.none() : Option.some(id);
+const fromField = (value) => Option.getOrElse(value, () => ID.local);
+/**
+* Filesystem-class taxonomy, mirroring Unix: disk, tmpfs/procfs, NFS/CIFS.
+* Stored on the row rather than derived from the registered driver, so reading
+* an instance never depends on the registry — which matters most when a driver
+* is *not* configured and you need to list or clean up its rows.
+*/
+const Kind = Schema.Literals([
+	"local",
+	"virtual",
+	"remote"
+]);
+const Ownership = Schema.Literals(["managed", "external"]);
+/**
+* Lifecycle state, in ZFS pool vocabulary. This is the **last observed** value,
+* not live driver truth: Daytona auto-stops and auto-archives, Vercel sandboxes
+* expire on their own timeout, so drift is normal. `stateObservedAt` carries the
+* freshness and `Controller.refresh` updates it without waking anything.
+*
+* `removed` and `unavail` are deliberately distinct. `removed` means we deleted
+* it; `unavail` means the driver claims it is gone. A "not found" is frequently a
+* misclassification — wrong region, wrong API url, a revoked key answering 404,
+* eventual consistency right after create — so it must never be recorded as if we
+* had destroyed the resource ourselves.
+*/
+const Status = Schema.Literals([
+	"provisioning",
+	"online",
+	"offline",
+	"suspending",
+	"removing",
+	"removed",
+	"unavail",
+	"faulted"
+]);
+/**
+* The statuses a `mount` may proceed from. This is the predicate every
+* conditional write depends on, so it is enumerated once here rather than
+* restated as prose at each call site.
+*
+* `offline` qualifies because mounting wakes.
+* `faulted` qualifies because a fault is a *usability* condition, not an identity one — see {@link Status}.
+*
+* There is no `resuming`: it would exist to be observed by nothing, since
+* mounting wakes, `offline` is already mountable, and waking is not destructive
+* so it needs no claim. `suspending` and `removing` stay because they *are*
+* compare-and-set claims, blocking a concurrent mount mid-destruction.
+*/
+const mountable = /* @__PURE__ */ new Set([
+	"online",
+	"offline",
+	"faulted"
+]);
+const isMountable = (status) => mountable.has(status);
+/**
+* Reference state, derived — never stored. `busy` carries its `umount` meaning:
+* something holds this and destruction must not proceed unforced.
+*
+* `pinned` is the kernel sense of the word: never reclaimable. It short-circuits
+* counting entirely for instances that cannot be stopped or destroyed (the local
+* host), which is what keeps them out of any future collector by construction
+* rather than by an ownership check happening to catch them.
+*/
+const Usage = Schema.Literals([
+	"idle",
+	"busy",
+	"pinned"
+]);
+/** Sanitized driver failure. The only error shape allowed to be persisted or logged. */
+const PersistedError = Schema.Struct({
+	name: Schema.String,
+	message: Schema.String,
+	code: Schema.optional(Schema.String)
+});
+//#endregion
+export { ID, Kind, Ownership, PersistedError, instance_exports as SandboxInstance, Status, Usage, fromColumn, fromField, isMountable, mountable, toColumn, toField };
+
+//# sourceMappingURL=instance.mjs.map

package/sandbox/instance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.mjs","names":[],"sources":["../../../src/sandbox/instance.ts"],"sourcesContent":["import { Option, Schema } from \"effect\";\nimport { uuidv7 } from \"uuidv7\";\nimport { withStatics } from \"../schema.ts\";\nimport type { SandboxDriver } from \"./driver.ts\";\n\n/**\n * A Sandbox instance is a **durable filesystem namespace** plus whatever compute\n * acts on it — a device in Unix terms, which exists whether or not anything has\n * it mounted. `Sandbox.Controller` is the only thing that creates,\n * stops, or destroys one; this module is just its identity and state model.\n *\n * The application ID is deliberately separate from the driver's own resource\n * locator: callers never parse a Vercel name or a Daytona ID, driver formats may\n * change, and a destroyed resource must stay identifiable in Project/Session\n * history. A missing resource is never recreated under an existing ID — a new\n * resource is a new namespace and therefore a new ID.\n */\n\nexport const ID = Schema.String.pipe(\n\tSchema.brand(\"SandboxInstance.ID\"),\n\twithStatics((schema) => ({\n\t\t/**\n\t\t * The host. Reserved, and never written to a column — see {@link toColumn}.\n\t\t * It exists at runtime so nothing has to branch on \"is this the host\": it is\n\t\t * what identity reads, what logs show, and what the transport cache keys on.\n\t\t */\n\t\tlocal: schema.make(\"local\"),\n\t\t/** A fresh identity for a namespace nothing has named yet. */\n\t\tcreate: () => schema.make(`sbx_${uuidv7()}`),\n\t})),\n);\nexport type ID = typeof ID.Type;\n\n/**\n * The storage boundary for namespace references, in one place.\n *\n * The host filesystem exists whether or not a row describes it, so it gets no\n * row and `NULL` is the only spelling of it — the Unix analogue is exact, since\n * `/` has no entry in the mount table you consult to find other mounts. That\n * makes a session or directory writable before any namespace is registered (the\n * foreign key is skipped on NULL), makes `SET sandbox_instance_id = NULL` a\n * meaningful \"revert to the host\", and leaves the host impossible to tombstone,\n * collect, or destroy, because there is nothing to point at.\n *\n * Two SQLite consequences ride on this and break correctness silently if missed:\n * unique indexes treat NULLs as distinct, so every uniqueness constraint\n * spanning a namespace column coalesces to `'local'`; and `= NULL` never\n * matches, so namespace-scoped reads use `IS`.\n */\nexport const toColumn = (id: ID): string | null => (id === ID.local ? null : id);\nexport const fromColumn = (value: string | null): ID => (value === null ? ID.local : ID.make(value));\n\n/**\n * The same mapping for row models, whose optional columns are `Option` rather\n * than `null`. Kept beside {@link toColumn} so the boundary stays one place:\n * `toColumn`/`fromColumn` for SQL parameters, these for `Model.FieldOption`.\n */\nexport const toField = (id: ID): Option.Option<ID> => (id === ID.local ? Option.none() : Option.some(id));\nexport const fromField = (value: Option.Option<ID>): ID => Option.getOrElse(value, () => ID.local);\n\n/**\n * Filesystem-class taxonomy, mirroring Unix: disk, tmpfs/procfs, NFS/CIFS.\n * Stored on the row rather than derived from the registered driver, so reading\n * an instance never depends on the registry — which matters most when a driver\n * is *not* configured and you need to list or clean up its rows.\n */\nexport const Kind = Schema.Literals([\"local\", \"virtual\", \"remote\"]);\nexport type Kind = typeof Kind.Type;\n\nexport const Ownership = Schema.Literals([\"managed\", \"external\"]);\nexport type Ownership = typeof Ownership.Type;\n\n/**\n * Lifecycle state, in ZFS pool vocabulary. This is the **last observed** value,\n * not live driver truth: Daytona auto-stops and auto-archives, Vercel sandboxes\n * expire on their own timeout, so drift is normal. `stateObservedAt` carries the\n * freshness and `Controller.refresh` updates it without waking anything.\n *\n * `removed` and `unavail` are deliberately distinct. `removed` means we deleted\n * it; `unavail` means the driver claims it is gone. A \"not found\" is frequently a\n * misclassification — wrong region, wrong API url, a revoked key answering 404,\n * eventual consistency right after create — so it must never be recorded as if we\n * had destroyed the resource ourselves.\n */\nexport const Status = Schema.Literals([\n\t\"provisioning\",\n\t\"online\",\n\t\"offline\",\n\t\"suspending\",\n\t\"removing\",\n\t\"removed\",\n\t\"unavail\",\n\t\"faulted\",\n]);\nexport type Status = typeof Status.Type;\n\n/**\n * The statuses a `mount` may proceed from. This is the predicate every\n * conditional write depends on, so it is enumerated once here rather than\n * restated as prose at each call site.\n *\n * `offline` qualifies because mounting wakes.\n * `faulted` qualifies because a fault is a *usability* condition, not an identity one — see {@link Status}.\n *\n * There is no `resuming`: it would exist to be observed by nothing, since\n * mounting wakes, `offline` is already mountable, and waking is not destructive\n * so it needs no claim. `suspending` and `removing` stay because they *are*\n * compare-and-set claims, blocking a concurrent mount mid-destruction.\n */\nexport const mountable: ReadonlySet<Status> = new Set<Status>([\"online\", \"offline\", \"faulted\"]);\n\nexport const isMountable = (status: Status): boolean => mountable.has(status);\n\n/**\n * Reference state, derived — never stored. `busy` carries its `umount` meaning:\n * something holds this and destruction must not proceed unforced.\n *\n * `pinned` is the kernel sense of the word: never reclaimable. It short-circuits\n * counting entirely for instances that cannot be stopped or destroyed (the local\n * host), which is what keeps them out of any future collector by construction\n * rather than by an ownership check happening to catch them.\n */\nexport const Usage = Schema.Literals([\"idle\", \"busy\", \"pinned\"]);\nexport type Usage = typeof Usage.Type;\n\n/** Sanitized driver failure. The only error shape allowed to be persisted or logged. */\nexport const PersistedError = Schema.Struct({\n\tname: Schema.String,\n\tmessage: Schema.String,\n\tcode: Schema.optional(Schema.String),\n});\nexport type PersistedError = typeof PersistedError.Type;\n\n/** Durable metadata, safe to return and persist. Assembled by the control plane. */\nexport interface Info {\n\treadonly id: ID;\n\treadonly driver: SandboxDriver.Name;\n\treadonly kind: Kind;\n\treadonly providerResourceId: Option.Option<string>;\n\treadonly ownership: Ownership;\n\treadonly status: Status;\n\treadonly usage: Usage;\n\t/** References held by *this* control plane. Process-local; see the transport cache. */\n\treadonly refCount: number;\n\treadonly providerStatus: Option.Option<string>;\n\treadonly metadata: Readonly<Record<string, string>>;\n\treadonly lastError: Option.Option<PersistedError>;\n\treadonly createdAt: Date;\n\treadonly updatedAt: Date;\n\treadonly stateObservedAt: Date;\n\treadonly lastMountedAt: Option.Option<Date>;\n\treadonly lastUnmountedAt: Option.Option<Date>;\n\treadonly lastUsedAt: Option.Option<Date>;\n\treadonly removedAt: Option.Option<Date>;\n}\n\nexport * as SandboxInstance from \"./instance.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,MAAa,KAAK,OAAO,OAAO,KAC/B,OAAO,MAAM,oBAAoB,GACjC,aAAa,YAAY;;;;;;CAMxB,OAAO,OAAO,KAAK,OAAO;;CAE1B,cAAc,OAAO,KAAK,OAAO,OAAO,GAAG;AAC5C,EAAE,CACH;;;;;;;;;;;;;;;;;AAmBA,MAAa,YAAY,OAA2B,OAAO,GAAG,QAAQ,OAAO;AAC7E,MAAa,cAAc,UAA8B,UAAU,OAAO,GAAG,QAAQ,GAAG,KAAK,KAAK;;;;;;AAOlG,MAAa,WAAW,OAA+B,OAAO,GAAG,QAAQ,OAAO,KAAK,IAAI,OAAO,KAAK,EAAE;AACvG,MAAa,aAAa,UAAiC,OAAO,UAAU,aAAa,GAAG,KAAK;;;;;;;AAQjG,MAAa,OAAO,OAAO,SAAS;CAAC;CAAS;CAAW;AAAQ,CAAC;AAGlE,MAAa,YAAY,OAAO,SAAS,CAAC,WAAW,UAAU,CAAC;;;;;;;;;;;;;AAehE,MAAa,SAAS,OAAO,SAAS;CACrC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACD,CAAC;;;;;;;;;;;;;;AAgBD,MAAa,4BAAiC,IAAI,IAAY;CAAC;CAAU;CAAW;AAAS,CAAC;AAE9F,MAAa,eAAe,WAA4B,UAAU,IAAI,MAAM;;;;;;;;;;AAW5E,MAAa,QAAQ,OAAO,SAAS;CAAC;CAAQ;CAAQ;AAAQ,CAAC;;AAI/D,MAAa,iBAAiB,OAAO,OAAO;CAC3C,MAAM,OAAO;CACb,SAAS,OAAO;CAChB,MAAM,OAAO,SAAS,OAAO,MAAM;AACpC,CAAC"}

package/sandbox/io.d.mts

@@ -0,0 +1,2 @@
+import { a as Provides, c as hostLayer, d as mount, f as remote, i as Layer, l as identityLayer, m as virtual, n as FileSystem, o as Shell, p as resolveMountCwd, r as Identity, s as host, t as Current, u as io_d_exports } from "../io-BYs7hbiY.mjs";
+export { Current, FileSystem, Identity, Layer, Provides, io_d_exports as SandboxIO, Shell, host, hostLayer, identityLayer, mount, remote, resolveMountCwd, virtual };

package/sandbox/io.mjs

@@ -0,0 +1,127 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ID } from "./instance.mjs";
+import { posix } from "../posix.mjs";
+import { Service, withCwd } from "./filesystem.mjs";
+import { Shell as Shell$1, withCwd as withCwd$1 } from "./shell.mjs";
+import { Context, Effect, Layer } from "effect";
+//#region src/sandbox/io.ts
+var io_exports = /* @__PURE__ */ __exportAll({
+	Current: () => Current,
+	FileSystem: () => FileSystem,
+	SandboxIO: () => io_exports,
+	Shell: () => Shell,
+	host: () => host,
+	hostLayer: () => hostLayer,
+	identityLayer: () => identityLayer,
+	mount: () => mount,
+	remote: () => remote,
+	resolveMountCwd: () => resolveMountCwd,
+	virtual: () => virtual
+});
+/**
+* `SandboxIO` is a **mount**: a filesystem, a shell, and the identity and
+* working directory they act on.
+*
+* It is the whole vocabulary a consumer needs. Project, Git, Copy, Location, and
+* every tool ask for `SandboxIO.FileSystem`, `SandboxIO.Shell`, and
+* `SandboxIO.Current` — never for a driver, an address, or a provider SDK — so
+* a host directory, an in-memory VFS, and a remote microVM are interchangeable
+* behind one contract.
+*
+* The mount neither creates nor destroys infrastructure. `SandboxInstance` is
+* the durable namespace it acts on — a device, which exists whether or not
+* anything has it mounted — and `Sandbox.Controller` is the only path that
+* creates, stops, or destroys one.
+*/
+/**
+* The filesystem tag. Re-exported here so consumers import one namespace —
+* Project, Git, Copy, and the runner ask for `SandboxIO.FileSystem`, never for
+* the module that happens to define it. Code *inside* `sandbox/` keeps importing
+* the tag directly, since `io.ts` is built on top of it.
+*/
+const FileSystem = Service;
+/** The shell tag. Re-exported here so consumers import one namespace. */
+const Shell = Shell$1;
+/** Identity and working directory of the current mount. */
+var Current = class extends Context.Service()("@codeworksh/plugin/sandbox/io/Current") {};
+/**
+* Resolve a mount's cwd without consulting ambient process state.
+*
+* The default is supplied by the namespace adapter:
+* provider metadata remotely, `/` for a virtual filesystem, and `process.cwd()` for the host adapter.
+* An explicit absolute cwd replaces it; a relative cwd is resolved inside it. The
+* result is therefore always the one concrete absolute path `Current` requires.
+*
+* A non-absolute default throws rather than failing typed. It is the one
+* defect-level guard in this module, and deliberately so:
+* Adapters reading a value from a provider call this inside their own error channel,
+* where the throw becomes their typed failure (see `EnvDaytona.mountCwd`).
+*/
+const resolveMountCwd = (defaultCwd, cwd) => {
+	if (!posix.isAbsolute(defaultCwd)) throw new TypeError(`Sandbox default cwd must be absolute: ${defaultCwd}`);
+	if (cwd === void 0) return posix.resolve(defaultCwd);
+	return posix.isAbsolute(cwd) ? posix.resolve(cwd) : posix.resolve(defaultCwd, cwd);
+};
+/**
+* Bind a cwd-neutral transport to one mount.
+*
+* The transport underneath is shared between
+* mounts and stays rooted at the namespace root, and everything directory-shaped
+* happens here, once per mount. Two mounts of one namespace at different working
+* directories therefore coexist without seeing or moving each other's.
+*
+* It consumes the same two tags it provides — the transport is supplied by the
+* layer this is composed over, not by itself.
+*/
+const mount = (identity) => Layer.mergeAll(Layer.succeed(Current, identity), Layer.effect(Service, Effect.map(Service, (fs) => withCwd(fs, identity.cwd))), Layer.effect(Shell$1, Effect.map(Shell$1, (shell) => withCwd$1(shell, identity.cwd))));
+/**
+* Just the identity tag, with no filesystem or shell beneath it. For consumers
+* assembled from stubs — a test that runs `Project` over a fake filesystem still
+* needs to know which namespace it is in.
+*/
+const identityLayer = (identity) => Layer.succeed(Current, identity);
+/** The host identity alone. See {@link identityLayer}. */
+const hostLayer = (cwd) => identityLayer(host(cwd));
+/**
+* The host, rooted at `cwd`. Always `SandboxInstance.ID.local`: the working
+* directory selects where relative paths resolve, it does not make a second host
+* namespace — two mounts rooted at different directories still agree on absolute
+* paths.
+*
+* The host coordinate is explicit so a caller cannot accidentally substitute ambient process
+* state for the application or session directory it owns.
+*/
+const host = (cwd) => ({
+	id: ID.local,
+	driver: "local",
+	kind: "local",
+	cwd: resolveMountCwd(cwd)
+});
+/**
+* A VFS-backed namespace. The id is minted per call unless one is named, because
+* building one of these builds a fresh VFS: N unnamed calls are N distinct
+* namespaces, none of which outlives the process. A file-backed store is the
+* exception — its file is the state, so whoever knows the file supplies the id
+* it was registered under.
+*/
+const virtual = (input) => ({
+	id: input.id ?? ID.create(),
+	driver: input.driver,
+	kind: "virtual",
+	cwd: resolveMountCwd(input.defaultCwd ?? "/", input.cwd)
+});
+/**
+* A provider-hosted namespace. The id is always supplied: a remote resource's
+* durable identity is minted and recorded by whoever provisioned it, never
+* derived here from the provider's own locator.
+*/
+const remote = (input) => ({
+	id: input.id,
+	driver: input.driver,
+	kind: "remote",
+	cwd: resolveMountCwd(input.defaultCwd, input.cwd)
+});
+//#endregion
+export { Current, FileSystem, io_exports as SandboxIO, Shell, host, hostLayer, identityLayer, mount, remote, resolveMountCwd, virtual };
+
+//# sourceMappingURL=io.mjs.map

package/sandbox/io.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"io.mjs","names":["SandboxFileSystem.Service","ShellTag","EffectLayer","SandboxFileSystem.withCwd","shellWithCwd"],"sources":["../../../src/sandbox/io.ts"],"sourcesContent":["import { Context, Effect, Layer as EffectLayer } from \"effect\";\nimport { posix } from \"../posix.ts\";\nimport type { SandboxDriver } from \"./driver.ts\";\nimport { SandboxFileSystem } from \"./filesystem.ts\";\nimport { SandboxInstance } from \"./instance.ts\";\nimport { type ISandboxExe, Shell as ShellTag, withCwd as shellWithCwd } from \"./shell.ts\";\n\n/**\n * `SandboxIO` is a **mount**: a filesystem, a shell, and the identity and\n * working directory they act on.\n *\n * It is the whole vocabulary a consumer needs. Project, Git, Copy, Location, and\n * every tool ask for `SandboxIO.FileSystem`, `SandboxIO.Shell`, and\n * `SandboxIO.Current` — never for a driver, an address, or a provider SDK — so\n * a host directory, an in-memory VFS, and a remote microVM are interchangeable\n * behind one contract.\n *\n * The mount neither creates nor destroys infrastructure. `SandboxInstance` is\n * the durable namespace it acts on — a device, which exists whether or not\n * anything has it mounted — and `Sandbox.Controller` is the only path that\n * creates, stops, or destroys one.\n */\n\n/**\n * The filesystem tag. Re-exported here so consumers import one namespace —\n * Project, Git, Copy, and the runner ask for `SandboxIO.FileSystem`, never for\n * the module that happens to define it. Code *inside* `sandbox/` keeps importing\n * the tag directly, since `io.ts` is built on top of it.\n */\nexport const FileSystem = SandboxFileSystem.Service;\nexport type FileSystem = SandboxFileSystem.Service;\n\n/** The shell tag. Re-exported here so consumers import one namespace. */\nexport const Shell = ShellTag;\nexport type Shell = ShellTag;\n\n/**\n * What a mount sees: immutable identity, plus the working directory resolved for\n * *this* mount.\n *\n * Nothing mutable belongs here. `status`, `usage`, and reference counts all\n * change while a mount is open, so a mount-time snapshot of them would be wrong\n * by construction — runtime code that needs live management state asks the\n * control plane. The driver's own resource locator is likewise absent: consumers\n * never parse a Vercel name or a Daytona id.\n */\nexport interface Identity {\n\treadonly id: SandboxInstance.ID;\n\treadonly driver: SandboxDriver.Name;\n\treadonly kind: SandboxInstance.Kind;\n\t/** Absolute, and always a path in *this* namespace. */\n\treadonly cwd: string;\n}\n\n/** Identity and working directory of the current mount. */\nexport class Current extends Context.Service<Current, Identity>()(\"@codeworksh/plugin/sandbox/io/Current\") {}\n\n/** Everything a mount provides. */\nexport type Provides = Current | SandboxFileSystem.Service | ShellTag;\n\n/** A built mount. */\nexport type Layer<E = never, RIn = never> = EffectLayer.Layer<Provides, E, RIn>;\n\n/**\n * Resolve a mount's cwd without consulting ambient process state.\n *\n * The default is supplied by the namespace adapter:\n * provider metadata remotely, `/` for a virtual filesystem, and `process.cwd()` for the host adapter.\n * An explicit absolute cwd replaces it; a relative cwd is resolved inside it. The\n * result is therefore always the one concrete absolute path `Current` requires.\n *\n * A non-absolute default throws rather than failing typed. It is the one\n * defect-level guard in this module, and deliberately so:\n * Adapters reading a value from a provider call this inside their own error channel,\n * where the throw becomes their typed failure (see `EnvDaytona.mountCwd`).\n */\nexport const resolveMountCwd = (defaultCwd: string, cwd?: string): string => {\n\tif (!posix.isAbsolute(defaultCwd)) {\n\t\tthrow new TypeError(`Sandbox default cwd must be absolute: ${defaultCwd}`);\n\t}\n\t// `resolve`, not `normalize`: normalize keeps a trailing slash, and `cwd` is\n\t// persisted — `space.location` and its id hash would read\n\t// `/workspace/` and `/workspace` as two directories and keep a row for each.\n\t//\n\t// A provider-reported default (`getWorkDir()`) or a config value is free to\n\t// carry one, so it is stripped here rather than at every reader.\n\tif (cwd === undefined) return posix.resolve(defaultCwd);\n\treturn posix.isAbsolute(cwd) ? posix.resolve(cwd) : posix.resolve(defaultCwd, cwd);\n};\n\n/**\n * Bind a cwd-neutral transport to one mount.\n *\n * The transport underneath is shared between\n * mounts and stays rooted at the namespace root, and everything directory-shaped\n * happens here, once per mount. Two mounts of one namespace at different working\n * directories therefore coexist without seeing or moving each other's.\n *\n * It consumes the same two tags it provides — the transport is supplied by the\n * layer this is composed over, not by itself.\n */\nexport const mount = (identity: Identity): EffectLayer.Layer<Provides, never, SandboxFileSystem.Service | ShellTag> =>\n\tEffectLayer.mergeAll(\n\t\tEffectLayer.succeed(Current, identity),\n\t\tEffectLayer.effect(\n\t\t\tSandboxFileSystem.Service,\n\t\t\tEffect.map(SandboxFileSystem.Service, (fs) => SandboxFileSystem.withCwd(fs, identity.cwd)),\n\t\t),\n\t\tEffectLayer.effect(\n\t\t\tShellTag,\n\t\t\tEffect.map(ShellTag, (shell: ISandboxExe) => shellWithCwd(shell, identity.cwd)),\n\t\t),\n\t);\n\n/**\n * Just the identity tag, with no filesystem or shell beneath it. For consumers\n * assembled from stubs — a test that runs `Project` over a fake filesystem still\n * needs to know which namespace it is in.\n */\nexport const identityLayer = (identity: Identity) => EffectLayer.succeed(Current, identity);\n\n/** The host identity alone. See {@link identityLayer}. */\nexport const hostLayer = (cwd: string) => identityLayer(host(cwd));\n\n/**\n * The host, rooted at `cwd`. Always `SandboxInstance.ID.local`: the working\n * directory selects where relative paths resolve, it does not make a second host\n * namespace — two mounts rooted at different directories still agree on absolute\n * paths.\n *\n * The host coordinate is explicit so a caller cannot accidentally substitute ambient process\n * state for the application or session directory it owns.\n */\nexport const host = (cwd: string): Identity => ({\n\tid: SandboxInstance.ID.local,\n\tdriver: \"local\" as SandboxDriver.Name,\n\tkind: \"local\",\n\tcwd: resolveMountCwd(cwd),\n});\n\n/**\n * A VFS-backed namespace. The id is minted per call unless one is named, because\n * building one of these builds a fresh VFS: N unnamed calls are N distinct\n * namespaces, none of which outlives the process. A file-backed store is the\n * exception — its file is the state, so whoever knows the file supplies the id\n * it was registered under.\n */\nexport const virtual = (input: {\n\treadonly driver: string;\n\treadonly id?: SandboxInstance.ID;\n\treadonly defaultCwd?: string;\n\treadonly cwd?: string;\n}): Identity => ({\n\tid: input.id ?? SandboxInstance.ID.create(),\n\tdriver: input.driver as SandboxDriver.Name,\n\tkind: \"virtual\",\n\tcwd: resolveMountCwd(input.defaultCwd ?? \"/\", input.cwd),\n});\n\n/**\n * A provider-hosted namespace. The id is always supplied: a remote resource's\n * durable identity is minted and recorded by whoever provisioned it, never\n * derived here from the provider's own locator.\n */\nexport const remote = (input: {\n\treadonly driver: string;\n\treadonly id: SandboxInstance.ID;\n\t/** Namespace-intrinsic default supplied or discovered by the driver. */\n\treadonly defaultCwd: string;\n\treadonly cwd?: string;\n}): Identity => ({\n\tid: input.id,\n\tdriver: input.driver as SandboxDriver.Name,\n\tkind: \"remote\",\n\tcwd: resolveMountCwd(input.defaultCwd, input.cwd),\n});\n\nexport * as SandboxIO from \"./io.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,aAAaA;;AAI1B,MAAa,QAAQC;;AAsBrB,IAAa,UAAb,cAA6B,QAAQ,QAA2B,CAAC,CAAC,uCAAuC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;AAqB5G,MAAa,mBAAmB,YAAoB,QAAyB;CAC5E,IAAI,CAAC,MAAM,WAAW,UAAU,GAC/B,MAAM,IAAI,UAAU,yCAAyC,YAAY;CAQ1E,IAAI,QAAQ,KAAA,GAAW,OAAO,MAAM,QAAQ,UAAU;CACtD,OAAO,MAAM,WAAW,GAAG,IAAI,MAAM,QAAQ,GAAG,IAAI,MAAM,QAAQ,YAAY,GAAG;AAClF;;;;;;;;;;;;AAaA,MAAa,SAAS,aACrBC,MAAY,SACXA,MAAY,QAAQ,SAAS,QAAQ,GACrCA,MAAY,OACXF,SACA,OAAO,IAAIA,UAA4B,OAAOG,QAA0B,IAAI,SAAS,GAAG,CAAC,CAC1F,GACAD,MAAY,OACXD,SACA,OAAO,IAAIA,UAAW,UAAuBG,UAAa,OAAO,SAAS,GAAG,CAAC,CAC/E,CACD;;;;;;AAOD,MAAa,iBAAiB,aAAuBF,MAAY,QAAQ,SAAS,QAAQ;;AAG1F,MAAa,aAAa,QAAgB,cAAc,KAAK,GAAG,CAAC;;;;;;;;;;AAWjE,MAAa,QAAQ,SAA2B;CAC/C,IAAA,GAAuB;CACvB,QAAQ;CACR,MAAM;CACN,KAAK,gBAAgB,GAAG;AACzB;;;;;;;;AASA,MAAa,WAAW,WAKP;CAChB,IAAI,MAAM,MAAA,GAAyB,OAAO;CAC1C,QAAQ,MAAM;CACd,MAAM;CACN,KAAK,gBAAgB,MAAM,cAAc,KAAK,MAAM,GAAG;AACxD;;;;;;AAOA,MAAa,UAAU,WAMN;CAChB,IAAI,MAAM;CACV,QAAQ,MAAM;CACd,MAAM;CACN,KAAK,gBAAgB,MAAM,YAAY,MAAM,GAAG;AACjD"}

package/sandbox/resource.d.mts

@@ -0,0 +1,28 @@
+import { Context } from "effect";
+declare namespace resource_d_exports {
+  export { resource_d_exports as SandboxResource, Service };
+}
+declare const Service_base: Context.ServiceClass<Service, "@codeworksh/plugin/sandbox/resource/Service", {
+  readonly providerResourceId: string;
+}>;
+/**
+ * The driver's own locator for the attached resource — a Vercel sandbox name, a
+ * Daytona sandbox id.
+ *
+ * Deliberately *not* on `SandboxIO.Current`: consumers never parse one,
+ * and keeps it separate from the application id precisely so a driver's format can
+ * change without touching identity.
+ *
+ * It exists for the control plane, which records it as `provider_resource_id`,
+ * and for tests that reattach to the same resource.
+ *
+ * One tag for every driver rather than one per driver. A mount has exactly one
+ * driver, so there is nothing to disambiguate, and the control plane has to read
+ * the locator without knowing which driver produced it — keeps the
+ * driver name open, so anything keyed on a closed `"vercel" | "daytona"` set is
+ * a bug waiting for the third driver.
+ */
+export declare class Service extends Service_base {}
+//#endregion
+export { resource_d_exports as SandboxResource };
+//# sourceMappingURL=resource.d.mts.map

package/sandbox/resource.mjs

@@ -0,0 +1,29 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { Context } from "effect";
+//#region src/sandbox/resource.ts
+var resource_exports = /* @__PURE__ */ __exportAll({
+	SandboxResource: () => resource_exports,
+	Service: () => Service
+});
+/**
+* The driver's own locator for the attached resource — a Vercel sandbox name, a
+* Daytona sandbox id.
+*
+* Deliberately *not* on `SandboxIO.Current`: consumers never parse one,
+* and keeps it separate from the application id precisely so a driver's format can
+* change without touching identity.
+*
+* It exists for the control plane, which records it as `provider_resource_id`,
+* and for tests that reattach to the same resource.
+*
+* One tag for every driver rather than one per driver. A mount has exactly one
+* driver, so there is nothing to disambiguate, and the control plane has to read
+* the locator without knowing which driver produced it — keeps the
+* driver name open, so anything keyed on a closed `"vercel" | "daytona"` set is
+* a bug waiting for the third driver.
+*/
+var Service = class extends Context.Service()("@codeworksh/plugin/sandbox/resource/Service") {};
+//#endregion
+export { resource_exports as SandboxResource, Service };
+
+//# sourceMappingURL=resource.mjs.map

package/sandbox/resource.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.mjs","names":[],"sources":["../../../src/sandbox/resource.ts"],"sourcesContent":["import { Context } from \"effect\";\n\n/**\n * The driver's own locator for the attached resource — a Vercel sandbox name, a\n * Daytona sandbox id.\n *\n * Deliberately *not* on `SandboxIO.Current`: consumers never parse one,\n * and keeps it separate from the application id precisely so a driver's format can\n * change without touching identity.\n *\n * It exists for the control plane, which records it as `provider_resource_id`,\n * and for tests that reattach to the same resource.\n *\n * One tag for every driver rather than one per driver. A mount has exactly one\n * driver, so there is nothing to disambiguate, and the control plane has to read\n * the locator without knowing which driver produced it — keeps the\n * driver name open, so anything keyed on a closed `\"vercel\" | \"daytona\"` set is\n * a bug waiting for the third driver.\n */\nexport class Service extends Context.Service<Service, { readonly providerResourceId: string }>()(\n\t\"@codeworksh/plugin/sandbox/resource/Service\",\n) {}\n\nexport * as SandboxResource from \"./resource.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAmBA,IAAa,UAAb,cAA6B,QAAQ,QAA0D,CAAC,CAC/F,6CACD,CAAC,CAAC,CAAC"}

package/sandbox/shell.d.mts

@@ -0,0 +1,2 @@
+import { a as ShellError, c as perMount, d as resolveCwd, f as withCwd, i as Shell, l as quote, n as ExecResult, o as ShellOptions, r as ISandboxExe, s as fromExec, t as ExecChunk, u as quoteArgv } from "../shell-CZ6Y4lNU.mjs";
+export { ExecChunk, ExecResult, ISandboxExe, Shell, ShellError, ShellOptions, fromExec, perMount, quote, quoteArgv, resolveCwd, withCwd };

package/sandbox/shell.mjs

@@ -0,0 +1,93 @@
+import { posix } from "../posix.mjs";
+import { Context, Schema } from "effect";
+//#region src/sandbox/shell.ts
+/**
+* The pluggable execution contract. Local sandboxes usually get a Shell through
+* just-bash over the local `Local.Vfs`; remote sandboxes provide their own
+* native Shell. Either way the rest of the harness depends only on this service
+* tag.
+*/
+var ShellError = class extends Schema.TaggedError()("ShellError", {
+	command: Schema.String,
+	cause: Schema.optional(Schema.Defect())
+}) {};
+/**
+* Mount-local shell factories are attached out-of-band so the public Shell
+* contract stays about command execution only.
+*
+* Most transports are safely shared and need only the cwd wrapper below.
+* Stateful in-process interpreters use this hook to construct one interpreter
+* per mount while retaining the underlying filesystem transport. This tag must
+* remain on the outermost wrapper consumed by {@link withCwd}; wrapper helpers
+* such as {@link fromExec} must propagate it when they return a new object.
+*/
+const mountFactories = /* @__PURE__ */ new WeakMap();
+const perMount = (transport, make) => {
+	mountFactories.set(transport, make);
+	return transport;
+};
+/**
+* POSIX single-quote escaping: wrap in `'…'` and rewrite each embedded quote as
+* `'\''`. Everything inside single quotes is literal to the shell, so this is
+* safe for arbitrary bytes.
+*/
+const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+/** Render an argument vector as one shell-safe command string. */
+const quoteArgv = (argv) => argv.map(quote).join(" ");
+/**
+* Resolve a per-command cwd against the sandbox cwd. Passing a relative cwd
+* straight to a host or remote process API would otherwise resolve it against
+* that API's own default, which need not be the filesystem's configured cwd.
+*/
+const resolveCwd = (base, cwd) => {
+	if (cwd === void 0 || posix.isAbsolute(cwd) || base === void 0) return cwd ?? base;
+	return posix.resolve(base, cwd);
+};
+/**
+* Complete a string-only backend: `execArgv` quotes the vector and runs it
+* through `exec`. Backends that spawn a real argument vector (Vercel) implement
+* `execArgv` themselves instead, so the args never meet a shell parser at all.
+*
+* `cwd` rides the options rather than a `cd <dir> && …` prefix. Every backend
+* we wrap takes a working directory natively, and the prefix form cannot tell a
+* failed `cd` from a failed command — both arrive as one exit code.
+*/
+const fromExec = (backend) => {
+	const wrapped = {
+		...backend,
+		execArgv: (argv, options) => backend.exec(quoteArgv(argv), options)
+	};
+	const mountFactory = mountFactories.get(backend);
+	return mountFactory === void 0 ? wrapped : perMount(wrapped, (cwd) => fromExec(mountFactory(cwd)));
+};
+/**
+* Bind a cwd-neutral backend to one mount's working directory.
+*
+* The transport is shared between mounts and must stay rooted at the namespace
+* root, so the directory cannot live inside it: two mounts at different
+* directories would otherwise see each other's. This wrapper is per mount, and
+* an operation-level `cwd` still wins — resolved against the mount's, so a
+* relative one means what it reads like.
+*/
+const withCwd = (backend, cwd) => {
+	const mounted = mountFactories.get(backend)?.(cwd) ?? backend;
+	const at = (options) => {
+		const resolvedCwd = resolveCwd(cwd, options?.cwd);
+		return {
+			...options,
+			...resolvedCwd === void 0 ? {} : { cwd: resolvedCwd }
+		};
+	};
+	const stream = mounted.stream;
+	return {
+		exec: (command, options) => mounted.exec(command, at(options)),
+		execArgv: (argv, options) => mounted.execArgv(argv, at(options)),
+		...stream === void 0 ? {} : { stream: (command, options) => stream(command, at(options)) }
+	};
+};
+/** Execution service — the live {@link ISandboxExe} for the active sandbox. */
+var Shell = class extends Context.Service()("@codeworksh/plugin/sandbox/shell") {};
+//#endregion
+export { Shell, ShellError, fromExec, perMount, quote, quoteArgv, resolveCwd, withCwd };
+
+//# sourceMappingURL=shell.mjs.map

package/sandbox/shell.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell.mjs","names":["path"],"sources":["../../../src/sandbox/shell.ts"],"sourcesContent":["import { Context, type Effect, Schema, type Stream } from \"effect\";\nimport { posix as path } from \"../posix.ts\";\n\n/**\n * The pluggable execution contract. Local sandboxes usually get a Shell through\n * just-bash over the local `Local.Vfs`; remote sandboxes provide their own\n * native Shell. Either way the rest of the harness depends only on this service\n * tag.\n */\n\nexport class ShellError extends Schema.TaggedError<ShellError>()(\"ShellError\", {\n\tcommand: Schema.String,\n\tcause: Schema.optional(Schema.Defect()),\n}) {}\n\nexport interface ExecResult {\n\treadonly stdout: string;\n\treadonly stderr: string;\n\treadonly exitCode: number;\n}\n\n/**\n * One options shape for every entry point. `cwd` is the operation-level\n * override: it wins over the mount's working directory, and a relative value\n * resolves against it. Neither mutates shared state, so concurrent commands in\n * one mount can run in different directories.\n */\nexport interface ShellOptions {\n\treadonly env?: Record<string, string>;\n\treadonly cwd?: string;\n}\n\n/**\n * A streamed chunk of command output, terminated by a single `exit` carrying the\n * exit code. (A backend-level mirror of the tool layer's event; kept here so\n * `sandbox/` does not depend on `tool/`.)\n */\nexport type ExecChunk =\n\t| { readonly _tag: \"stdout\"; readonly bytes: Uint8Array }\n\t| { readonly _tag: \"stderr\"; readonly bytes: Uint8Array }\n\t| { readonly _tag: \"exit\"; readonly exitCode: number };\n\n/**\n * The command-execution capability a sandbox exposes. For an in-process\n * backend this is just-bash; for a remote backend it is the sandbox's own\n * shell. The {@link Shell} service tag carries this interface.\n */\nexport interface ISandboxExe {\n\treadonly exec: (command: string, options?: ShellOptions) => Effect.Effect<ExecResult, ShellError>;\n\t/**\n\t * Run a program with an explicit argument vector, bypassing shell word\n\t * splitting. Callers that build commands from untrusted values — branch\n\t * names, file paths — must use this instead of interpolating into\n\t * {@link exec}, where a space or `$(…)` would change what runs.\n\t *\n\t * Backends whose transport only accepts a string quote the vector with\n\t * {@link quote}; backends that spawn directly pass it through untouched.\n\t */\n\treadonly execArgv: (argv: ReadonlyArray<string>, options?: ShellOptions) => Effect.Effect<ExecResult, ShellError>;\n\t/**\n\t * Optional streaming output: stdout/stderr chunks then a terminal `exit`.\n\t * Backends that can stream (e.g. Vercel) implement it; `ToolShell.fromSandboxShell`\n\t * bridges it to `ToolShell.stream` so the bash tool streams over them too.\n\t */\n\treadonly stream?: (command: string, options?: ShellOptions) => Stream.Stream<ExecChunk, ShellError>;\n}\n\ntype MountFactory = (cwd: string) => ISandboxExe;\n\n/**\n * Mount-local shell factories are attached out-of-band so the public Shell\n * contract stays about command execution only.\n *\n * Most transports are safely shared and need only the cwd wrapper below.\n * Stateful in-process interpreters use this hook to construct one interpreter\n * per mount while retaining the underlying filesystem transport. This tag must\n * remain on the outermost wrapper consumed by {@link withCwd}; wrapper helpers\n * such as {@link fromExec} must propagate it when they return a new object.\n */\nconst mountFactories = new WeakMap<object, MountFactory>();\n\nexport const perMount = (transport: ISandboxExe, make: MountFactory): ISandboxExe => {\n\tmountFactories.set(transport, make);\n\treturn transport;\n};\n\n/**\n * POSIX single-quote escaping: wrap in `'…'` and rewrite each embedded quote as\n * `'\\''`. Everything inside single quotes is literal to the shell, so this is\n * safe for arbitrary bytes.\n */\nexport const quote = (value: string) => `'${value.replace(/'/g, `'\\\\''`)}'`;\n\n/** Render an argument vector as one shell-safe command string. */\nexport const quoteArgv = (argv: ReadonlyArray<string>) => argv.map(quote).join(\" \");\n\n/**\n * Resolve a per-command cwd against the sandbox cwd. Passing a relative cwd\n * straight to a host or remote process API would otherwise resolve it against\n * that API's own default, which need not be the filesystem's configured cwd.\n */\nexport const resolveCwd = (base: string | undefined, cwd: string | undefined) => {\n\tif (cwd === undefined || path.isAbsolute(cwd) || base === undefined) return cwd ?? base;\n\treturn path.resolve(base, cwd);\n};\n\n/**\n * Complete a string-only backend: `execArgv` quotes the vector and runs it\n * through `exec`. Backends that spawn a real argument vector (Vercel) implement\n * `execArgv` themselves instead, so the args never meet a shell parser at all.\n *\n * `cwd` rides the options rather than a `cd <dir> && …` prefix. Every backend\n * we wrap takes a working directory natively, and the prefix form cannot tell a\n * failed `cd` from a failed command — both arrive as one exit code.\n */\nexport const fromExec = (backend: Omit<ISandboxExe, \"execArgv\">): ISandboxExe => {\n\tconst wrapped: ISandboxExe = {\n\t\t...backend,\n\t\texecArgv: (argv, options) => backend.exec(quoteArgv(argv), options),\n\t};\n\tconst mountFactory = mountFactories.get(backend);\n\treturn mountFactory === undefined ? wrapped : perMount(wrapped, (cwd) => fromExec(mountFactory(cwd)));\n};\n\n/**\n * Bind a cwd-neutral backend to one mount's working directory.\n *\n * The transport is shared between mounts and must stay rooted at the namespace\n * root, so the directory cannot live inside it: two mounts at different\n * directories would otherwise see each other's. This wrapper is per mount, and\n * an operation-level `cwd` still wins — resolved against the mount's, so a\n * relative one means what it reads like.\n */\nexport const withCwd = (backend: ISandboxExe, cwd: string): ISandboxExe => {\n\tconst mounted = mountFactories.get(backend)?.(cwd) ?? backend;\n\tconst at = (options?: ShellOptions): ShellOptions => {\n\t\tconst resolvedCwd = resolveCwd(cwd, options?.cwd);\n\t\treturn { ...options, ...(resolvedCwd === undefined ? {} : { cwd: resolvedCwd }) };\n\t};\n\tconst stream = mounted.stream;\n\treturn {\n\t\texec: (command, options) => mounted.exec(command, at(options)),\n\t\texecArgv: (argv, options) => mounted.execArgv(argv, at(options)),\n\t\t...(stream === undefined ? {} : { stream: (command, options) => stream(command, at(options)) }),\n\t};\n};\n\n/** Execution service — the live {@link ISandboxExe} for the active sandbox. */\nexport class Shell extends Context.Service<Shell, ISandboxExe>()(\"@codeworksh/plugin/sandbox/shell\") {}\n"],"mappings":";;;;;;;;;AAUA,IAAa,aAAb,cAAgC,OAAO,YAAwB,CAAC,CAAC,cAAc;CAC9E,SAAS,OAAO;CAChB,OAAO,OAAO,SAAS,OAAO,OAAO,CAAC;AACvC,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;AAkEJ,MAAM,iCAAiB,IAAI,QAA8B;AAEzD,MAAa,YAAY,WAAwB,SAAoC;CACpF,eAAe,IAAI,WAAW,IAAI;CAClC,OAAO;AACR;;;;;;AAOA,MAAa,SAAS,UAAkB,IAAI,MAAM,QAAQ,MAAM,OAAO,EAAE;;AAGzE,MAAa,aAAa,SAAgC,KAAK,IAAI,KAAK,CAAC,CAAC,KAAK,GAAG;;;;;;AAOlF,MAAa,cAAc,MAA0B,QAA4B;CAChF,IAAI,QAAQ,KAAA,KAAaA,MAAK,WAAW,GAAG,KAAK,SAAS,KAAA,GAAW,OAAO,OAAO;CACnF,OAAOA,MAAK,QAAQ,MAAM,GAAG;AAC9B;;;;;;;;;;AAWA,MAAa,YAAY,YAAwD;CAChF,MAAM,UAAuB;EAC5B,GAAG;EACH,WAAW,MAAM,YAAY,QAAQ,KAAK,UAAU,IAAI,GAAG,OAAO;CACnE;CACA,MAAM,eAAe,eAAe,IAAI,OAAO;CAC/C,OAAO,iBAAiB,KAAA,IAAY,UAAU,SAAS,UAAU,QAAQ,SAAS,aAAa,GAAG,CAAC,CAAC;AACrG;;;;;;;;;;AAWA,MAAa,WAAW,SAAsB,QAA6B;CAC1E,MAAM,UAAU,eAAe,IAAI,OAAO,CAAC,GAAG,GAAG,KAAK;CACtD,MAAM,MAAM,YAAyC;EACpD,MAAM,cAAc,WAAW,KAAK,SAAS,GAAG;EAChD,OAAO;GAAE,GAAG;GAAS,GAAI,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,KAAK,YAAY;EAAG;CACjF;CACA,MAAM,SAAS,QAAQ;CACvB,OAAO;EACN,OAAO,SAAS,YAAY,QAAQ,KAAK,SAAS,GAAG,OAAO,CAAC;EAC7D,WAAW,MAAM,YAAY,QAAQ,SAAS,MAAM,GAAG,OAAO,CAAC;EAC/D,GAAI,WAAW,KAAA,IAAY,CAAC,IAAI,EAAE,SAAS,SAAS,YAAY,OAAO,SAAS,GAAG,OAAO,CAAC,EAAE;CAC9F;AACD;;AAGA,IAAa,QAAb,cAA2B,QAAQ,QAA4B,CAAC,CAAC,kCAAkC,CAAC,CAAC,CAAC"}

package/sandbox.d.mts

@@ -0,0 +1,17 @@
+import { A as apiVersion, C as Observed, D as RuntimeConfigBase, E as Registration, M as driver, O as RuntimeInput, S as Name, _ as Capabilities, a as Provides, b as Module, g as ApiVersion, h as AbsolutePath, i as Layer, j as defineModule, n as FileSystem, o as Shell, r as Identity, t as Current, v as Definition, vt as instance_d_exports, w as Provisioned, x as ModuleDefinition, y as Driver } from "./io-BYs7hbiY.mjs";
+import { c as filesystem_d_exports } from "./filesystem-Cp-KapCE.mjs";
+import { a as ShellError, i as Shell$1, l as quote, n as ExecResult, o as ShellOptions, r as ISandboxExe, s as fromExec, t as ExecChunk, u as quoteArgv } from "./shell-CZ6Y4lNU.mjs";
+import { t as error_d_exports } from "./sandbox/error.mjs";
+import { SandboxResource as resource_d_exports } from "./sandbox/resource.mjs";
+declare namespace driver_d_exports {
+  export { AbsolutePath, ApiVersion, Capabilities, Definition, Driver, Module, ModuleDefinition, Name, Observed, Provisioned, Registration, RuntimeConfigBase as RuntimeConfig, RuntimeConfigBase, RuntimeInput, driver_d_exports as SandboxDriver, apiVersion, driver, defineModule as module };
+}
+declare namespace io_d_exports {
+  export { Current, FileSystem, Identity, Layer, Provides, io_d_exports as SandboxIO, Shell };
+}
+declare namespace shell_d_exports {
+  export { ExecChunk, ExecResult, ISandboxExe, Shell$1 as Shell, ShellError, ShellOptions, fromExec, quote, quoteArgv };
+}
+//#endregion
+export { driver_d_exports as SandboxDriver, filesystem_d_exports as SandboxFileSystem, io_d_exports as SandboxIO, instance_d_exports as SandboxInstance, error_d_exports as SandboxProvider, resource_d_exports as SandboxResource, shell_d_exports as SandboxShell };
+//# sourceMappingURL=sandbox.d.mts.map

package/sandbox.mjs

@@ -0,0 +1,39 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { SandboxInstance as instance_exports } from "./sandbox/instance.mjs";
+import { SandboxFileSystem as filesystem_exports } from "./sandbox/filesystem.mjs";
+import { Shell, ShellError, fromExec, quote, quoteArgv } from "./sandbox/shell.mjs";
+import { Current, FileSystem, Shell as Shell$1 } from "./sandbox/io.mjs";
+import { AbsolutePath, Name, RuntimeConfigBase, driver, module as defineModule } from "./sandbox/driver.mjs";
+import { t as error_exports } from "./sandbox/error.mjs";
+import { SandboxResource as resource_exports } from "./sandbox/resource.mjs";
+//#region src/sandbox/public/driver.ts
+var driver_exports = /* @__PURE__ */ __exportAll({
+	AbsolutePath: () => AbsolutePath,
+	Name: () => Name,
+	RuntimeConfigBase: () => RuntimeConfigBase,
+	SandboxDriver: () => driver_exports,
+	apiVersion: () => 1,
+	driver: () => driver,
+	module: () => defineModule
+});
+//#endregion
+//#region src/sandbox/public/io.ts
+var io_exports = /* @__PURE__ */ __exportAll({
+	Current: () => Current,
+	FileSystem: () => FileSystem,
+	SandboxIO: () => io_exports,
+	Shell: () => Shell$1
+});
+//#endregion
+//#region src/sandbox/public/shell.ts
+var shell_exports = /* @__PURE__ */ __exportAll({
+	Shell: () => Shell,
+	ShellError: () => ShellError,
+	fromExec: () => fromExec,
+	quote: () => quote,
+	quoteArgv: () => quoteArgv
+});
+//#endregion
+export { driver_exports as SandboxDriver, filesystem_exports as SandboxFileSystem, io_exports as SandboxIO, instance_exports as SandboxInstance, error_exports as SandboxProvider, resource_exports as SandboxResource, shell_exports as SandboxShell };
+
+//# sourceMappingURL=sandbox.mjs.map

package/sandbox.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox.mjs","names":[],"sources":["../../src/sandbox/public/driver.ts","../../src/sandbox/public/io.ts","../../src/sandbox/public/shell.ts"],"sourcesContent":["export { AbsolutePath, apiVersion, driver, module, Name, RuntimeConfigBase } from \"../driver.ts\";\nexport type {\n\tApiVersion,\n\tCapabilities,\n\tDefinition,\n\tDriver,\n\tModule,\n\tModuleDefinition,\n\tObserved,\n\tProvisioned,\n\tRegistration,\n\tRuntimeConfigBase as RuntimeConfig,\n\tRuntimeInput,\n} from \"../driver.ts\";\n\nexport * as SandboxDriver from \"./driver.ts\";\n","export { Current, FileSystem, Shell } from \"../io.ts\";\nexport type { Identity, Layer, Provides } from \"../io.ts\";\n\nexport * as SandboxIO from \"./io.ts\";\n","export { fromExec, quote, quoteArgv, Shell, ShellError } from \"../shell.ts\";\nexport type { ExecChunk, ExecResult, ISandboxExe, ShellOptions } from \"../shell.ts\";\n"],"mappings":""}