@codeworksh/plugin 0.0.1-dev.20260922103030

package/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/sandbox/driver.d.mts

@@ -0,0 +1,2 @@
+import { A as apiVersion, C as Observed, D as RuntimeConfigBase, E as Registration, F as withSource, M as driver, N as driver_d_exports, O as RuntimeInput, P as erase, S as Name, T as Registered, _ as Capabilities, b as Module, g as ApiVersion, h as AbsolutePath, j as defineModule, k as Source, v as Definition, w as Provisioned, x as ModuleDefinition, y as Driver } from "../io-BYs7hbiY.mjs";
+export { AbsolutePath, ApiVersion, Capabilities, Definition, Driver, Module, ModuleDefinition, Name, Observed, Provisioned, Registered, Registration, RuntimeConfigBase, RuntimeInput, driver_d_exports as SandboxDriver, Source, apiVersion, driver, erase, defineModule as module, withSource };

package/sandbox/driver.mjs

@@ -0,0 +1,63 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import "./instance.mjs";
+import "./io.mjs";
+import { Schema } from "effect";
+//#region src/sandbox/driver.ts
+var driver_exports = /* @__PURE__ */ __exportAll({
+	AbsolutePath: () => AbsolutePath,
+	Name: () => Name,
+	RuntimeConfigBase: () => RuntimeConfigBase,
+	SandboxDriver: () => driver_exports,
+	apiVersion: () => 1,
+	driver: () => driver,
+	erase: () => erase,
+	module: () => defineModule,
+	withSource: () => withSource
+});
+/** Version of the loadable sandbox-driver module ABI. */
+const apiVersion = 1;
+/** Open driver identity. Adding a driver never extends a union in core. */
+const Name = Schema.String.check(Schema.isNonEmpty()).pipe(Schema.brand("SandboxDriver.Name"));
+/** A path whose coordinate system is the mounted namespace. */
+const AbsolutePath = Schema.String.check(Schema.isStartsWith("/")).pipe(Schema.brand("SandboxDriver.AbsolutePath"));
+const RuntimeConfigBase = Schema.Struct({ defaultCwd: AbsolutePath });
+const erase = (value) => ({
+	name: value.name,
+	kind: value.kind,
+	capabilities: value.capabilities,
+	createConfigCodec: value.createConfigCodec,
+	runtimeConfigCodec: value.runtimeConfigCodec,
+	create: (input) => value.create({
+		instanceId: input.instanceId,
+		config: input.config
+	}),
+	...value.runtimeConfigFor === void 0 ? {} : { runtimeConfigFor: (input) => value.runtimeConfigFor({
+		providerResourceId: input.providerResourceId,
+		...input.overrides === void 0 ? {} : { overrides: input.overrides }
+	}) },
+	attach: (input) => value.attach(input),
+	...value.inspect === void 0 ? {} : { inspect: (input) => value.inspect(input) },
+	...value.wake === void 0 ? {} : { wake: (input) => value.wake(input) },
+	...value.stop === void 0 ? {} : { stop: (input) => value.stop(input) },
+	...value.destroy === void 0 ? {} : { destroy: (input) => value.destroy(input) }
+});
+/** Define the default export of a loadable sandbox package. */
+const defineModule = (value) => ({
+	...value,
+	name: Name.make(value.name)
+});
+/** Construct a driver and its registry contribution. */
+const driver = (value) => Object.assign(value, {
+	registered: erase(value),
+	apiVersion: 1,
+	source: "builtin"
+});
+/** Attach trusted origin metadata without changing the driver implementation. */
+const withSource = (registration, source) => ({
+	...registration,
+	source
+});
+//#endregion
+export { AbsolutePath, Name, RuntimeConfigBase, driver_exports as SandboxDriver, apiVersion, driver, erase, defineModule as module, withSource };
+
+//# sourceMappingURL=driver.mjs.map

package/sandbox/driver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.mjs","names":[],"sources":["../../../src/sandbox/driver.ts"],"sourcesContent":["import { type Effect, type Layer, Option, Schema } from \"effect\";\nimport type { SandboxProviderError } from \"./errors.ts\";\nimport { SandboxInstance } from \"./instance.ts\";\nimport { SandboxIO } from \"./io.ts\";\n\n/** Version of the loadable sandbox-driver module ABI. */\nexport const apiVersion = 1 as const;\nexport type ApiVersion = typeof apiVersion;\n\n/** Open driver identity. Adding a driver never extends a union in core. */\nexport const Name = Schema.String.check(Schema.isNonEmpty()).pipe(Schema.brand(\"SandboxDriver.Name\"));\nexport type Name = typeof Name.Type;\n\n/** A path whose coordinate system is the mounted namespace. */\nexport const AbsolutePath = Schema.String.check(Schema.isStartsWith(\"/\")).pipe(\n\tSchema.brand(\"SandboxDriver.AbsolutePath\"),\n);\nexport type AbsolutePath = typeof AbsolutePath.Type;\n\nexport const RuntimeConfigBase = Schema.Struct({ defaultCwd: AbsolutePath });\nexport interface RuntimeConfigBase extends Schema.Schema.Type<typeof RuntimeConfigBase> {}\n\nexport interface Capabilities {\n\treadonly inspect: boolean;\n\treadonly reattach: boolean;\n\treadonly wake: boolean;\n\treadonly stop: boolean;\n\treadonly destroy: boolean;\n\treadonly cancels: boolean;\n}\n\nexport interface Observed {\n\treadonly status: SandboxInstance.Status;\n\treadonly providerStatus?: string | undefined;\n\treadonly metadata?: Readonly<Record<string, string>> | undefined;\n}\n\nexport interface Provisioned<RuntimeConfig extends RuntimeConfigBase> {\n\treadonly providerResourceId?: string | undefined;\n\treadonly providerStatus?: string | undefined;\n\treadonly runtimeConfig: RuntimeConfig;\n\treadonly metadata?: Readonly<Record<string, string>> | undefined;\n}\n\nexport interface RuntimeInput<RuntimeConfig extends RuntimeConfigBase> {\n\treadonly id: SandboxInstance.ID;\n\treadonly providerResourceId: Option.Option<string>;\n\treadonly runtimeConfig: RuntimeConfig;\n}\n\nexport interface Driver<CreateConfig, RuntimeConfig extends RuntimeConfigBase> {\n\treadonly name: Name;\n\treadonly kind: Exclude<SandboxInstance.Kind, \"local\">;\n\treadonly capabilities: Capabilities;\n\treadonly createConfigCodec: Schema.Codec<CreateConfig, unknown>;\n\treadonly runtimeConfigCodec: Schema.Codec<RuntimeConfig, unknown>;\n\treadonly create: (input: {\n\t\treadonly instanceId: SandboxInstance.ID;\n\t\treadonly config: CreateConfig;\n\t}) => Effect.Effect<Provisioned<RuntimeConfig>, SandboxProviderError>;\n\treadonly runtimeConfigFor?:\n\t\t| ((input: {\n\t\t\t\treadonly providerResourceId: string;\n\t\t\t\treadonly overrides?: Partial<RuntimeConfig> | undefined;\n\t\t  }) => Effect.Effect<RuntimeConfig, SandboxProviderError>)\n\t\t| undefined;\n\treadonly attach: (\n\t\tinput: RuntimeInput<RuntimeConfig>,\n\t) => Layer.Layer<SandboxIO.FileSystem | SandboxIO.Shell, SandboxProviderError>;\n\treadonly inspect?: (input: RuntimeInput<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;\n\treadonly wake?: (input: RuntimeInput<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;\n\treadonly stop?: (input: RuntimeInput<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;\n\treadonly destroy?: (input: RuntimeInput<RuntimeConfig>) => Effect.Effect<void, SandboxProviderError>;\n}\n\nexport type Definition<CreateConfig, RuntimeConfig extends RuntimeConfigBase> = Pick<\n\tDriver<CreateConfig, RuntimeConfig>,\n\t\"name\" | \"createConfigCodec\" | \"runtimeConfigCodec\"\n>;\n\n/** Registry-only erased shape. Driver authors construct it via {@link driver}. */\nexport interface Registered {\n\treadonly name: Name;\n\treadonly kind: Exclude<SandboxInstance.Kind, \"local\">;\n\treadonly capabilities: Capabilities;\n\treadonly createConfigCodec: Schema.Codec<unknown, unknown>;\n\treadonly runtimeConfigCodec: Schema.Codec<RuntimeConfigBase, unknown>;\n\treadonly create: (input: {\n\t\treadonly instanceId: SandboxInstance.ID;\n\t\treadonly config: unknown;\n\t}) => Effect.Effect<Provisioned<RuntimeConfigBase>, SandboxProviderError>;\n\treadonly runtimeConfigFor?:\n\t\t| ((input: {\n\t\t\t\treadonly providerResourceId: string;\n\t\t\t\treadonly overrides?: Readonly<Record<string, unknown>> | undefined;\n\t\t  }) => Effect.Effect<RuntimeConfigBase, SandboxProviderError>)\n\t\t| undefined;\n\treadonly attach: (\n\t\tinput: RuntimeInput<RuntimeConfigBase>,\n\t) => Layer.Layer<SandboxIO.FileSystem | SandboxIO.Shell, SandboxProviderError>;\n\treadonly inspect?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;\n\treadonly wake?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;\n\treadonly stop?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;\n\treadonly destroy?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<void, SandboxProviderError>;\n}\n\nexport const erase = <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(\n\tvalue: Driver<CreateConfig, RuntimeConfig>,\n): Registered => ({\n\tname: value.name,\n\tkind: value.kind,\n\tcapabilities: value.capabilities,\n\tcreateConfigCodec: value.createConfigCodec as Schema.Codec<unknown, unknown>,\n\truntimeConfigCodec: value.runtimeConfigCodec as Schema.Codec<RuntimeConfigBase, unknown>,\n\tcreate: (input) => value.create({ instanceId: input.instanceId, config: input.config as CreateConfig }),\n\t...(value.runtimeConfigFor === undefined\n\t\t? {}\n\t\t: {\n\t\t\t\truntimeConfigFor: (input: {\n\t\t\t\t\treadonly providerResourceId: string;\n\t\t\t\t\treadonly overrides?: Readonly<Record<string, unknown>> | undefined;\n\t\t\t\t}) =>\n\t\t\t\t\tvalue.runtimeConfigFor!({\n\t\t\t\t\t\tproviderResourceId: input.providerResourceId,\n\t\t\t\t\t\t...(input.overrides === undefined ? {} : { overrides: input.overrides as Partial<RuntimeConfig> }),\n\t\t\t\t\t}),\n\t\t\t}),\n\tattach: (input) => value.attach(input as RuntimeInput<RuntimeConfig>),\n\t...(value.inspect === undefined\n\t\t? {}\n\t\t: { inspect: (input: RuntimeInput<RuntimeConfigBase>) => value.inspect!(input as RuntimeInput<RuntimeConfig>) }),\n\t...(value.wake === undefined\n\t\t? {}\n\t\t: { wake: (input: RuntimeInput<RuntimeConfigBase>) => value.wake!(input as RuntimeInput<RuntimeConfig>) }),\n\t...(value.stop === undefined\n\t\t? {}\n\t\t: { stop: (input: RuntimeInput<RuntimeConfigBase>) => value.stop!(input as RuntimeInput<RuntimeConfig>) }),\n\t...(value.destroy === undefined\n\t\t? {}\n\t\t: { destroy: (input: RuntimeInput<RuntimeConfigBase>) => value.destroy!(input as RuntimeInput<RuntimeConfig>) }),\n});\n\nexport type Source = \"core\" | \"builtin\" | \"package\" | \"file\";\n\nexport interface Registration {\n\treadonly registered: Registered;\n\treadonly apiVersion: ApiVersion;\n\treadonly source: Source;\n}\n\nexport interface Module<Options> {\n\treadonly apiVersion: ApiVersion;\n\treadonly name: Name;\n\treadonly options: Schema.Codec<Options, unknown>;\n\treadonly make: (options: Options) => Registration;\n}\n\nexport interface ModuleDefinition<Options> {\n\treadonly apiVersion: ApiVersion;\n\treadonly name: string | Name;\n\treadonly options: Schema.Codec<Options, unknown>;\n\treadonly make: (options: Options) => Registration;\n}\n\n/** Define the default export of a loadable sandbox package. */\nconst defineModule = <Options>(value: ModuleDefinition<Options>): Module<Options> => ({\n\t...value,\n\tname: Name.make(value.name),\n});\nexport { defineModule as module };\n\n/** Construct a driver and its registry contribution. */\nexport const driver = <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(\n\tvalue: Driver<CreateConfig, RuntimeConfig>,\n): Driver<CreateConfig, RuntimeConfig> & Registration =>\n\tObject.assign(value, {\n\t\tregistered: erase(value),\n\t\tapiVersion,\n\t\tsource: \"builtin\" as const,\n\t});\n\n/** Attach trusted origin metadata without changing the driver implementation. */\nexport const withSource = (registration: Registration, source: Source): Registration => ({\n\t...registration,\n\tsource,\n});\n\nexport * as SandboxDriver from \"./driver.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;AAMA,MAAa,aAAa;;AAI1B,MAAa,OAAO,OAAO,OAAO,MAAM,OAAO,WAAW,CAAC,CAAC,CAAC,KAAK,OAAO,MAAM,oBAAoB,CAAC;;AAIpG,MAAa,eAAe,OAAO,OAAO,MAAM,OAAO,aAAa,GAAG,CAAC,CAAC,CAAC,KACzE,OAAO,MAAM,4BAA4B,CAC1C;AAGA,MAAa,oBAAoB,OAAO,OAAO,EAAE,YAAY,aAAa,CAAC;AAuF3E,MAAa,SACZ,WACiB;CACjB,MAAM,MAAM;CACZ,MAAM,MAAM;CACZ,cAAc,MAAM;CACpB,mBAAmB,MAAM;CACzB,oBAAoB,MAAM;CAC1B,SAAS,UAAU,MAAM,OAAO;EAAE,YAAY,MAAM;EAAY,QAAQ,MAAM;CAAuB,CAAC;CACtG,GAAI,MAAM,qBAAqB,KAAA,IAC5B,CAAC,IACD,EACA,mBAAmB,UAIlB,MAAM,iBAAkB;EACvB,oBAAoB,MAAM;EAC1B,GAAI,MAAM,cAAc,KAAA,IAAY,CAAC,IAAI,EAAE,WAAW,MAAM,UAAoC;CACjG,CAAC,EACH;CACF,SAAS,UAAU,MAAM,OAAO,KAAoC;CACpE,GAAI,MAAM,YAAY,KAAA,IACnB,CAAC,IACD,EAAE,UAAU,UAA2C,MAAM,QAAS,KAAoC,EAAE;CAC/G,GAAI,MAAM,SAAS,KAAA,IAChB,CAAC,IACD,EAAE,OAAO,UAA2C,MAAM,KAAM,KAAoC,EAAE;CACzG,GAAI,MAAM,SAAS,KAAA,IAChB,CAAC,IACD,EAAE,OAAO,UAA2C,MAAM,KAAM,KAAoC,EAAE;CACzG,GAAI,MAAM,YAAY,KAAA,IACnB,CAAC,IACD,EAAE,UAAU,UAA2C,MAAM,QAAS,KAAoC,EAAE;AAChH;;AAyBA,MAAM,gBAAyB,WAAuD;CACrF,GAAG;CACH,MAAM,KAAK,KAAK,MAAM,IAAI;AAC3B;;AAIA,MAAa,UACZ,UAEA,OAAO,OAAO,OAAO;CACpB,YAAY,MAAM,KAAK;CACvB,YAAA;CACA,QAAQ;AACT,CAAC;;AAGF,MAAa,cAAc,cAA4B,YAAkC;CACxF,GAAG;CACH;AACD"}

package/sandbox/error.d.mts

@@ -0,0 +1,7 @@
+import { I as Redactor, at as providerError, ct as sanitizeError, it as makeRedactor, ot as providerErrorCause, q as SandboxProviderError, st as providerErrorIsNotFound } from "../io-BYs7hbiY.mjs";
+declare namespace error_d_exports {
+  export { Redactor, SandboxProviderError, makeRedactor, providerError, providerErrorCause, providerErrorIsNotFound, sanitizeError };
+}
+//#endregion
+export { type Redactor, SandboxProviderError, makeRedactor, providerError, providerErrorCause, providerErrorIsNotFound, sanitizeError, error_d_exports as t };
+//# sourceMappingURL=error.d.mts.map

package/sandbox/error.mjs

@@ -0,0 +1,15 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { SandboxProviderError, makeRedactor, providerError, providerErrorCause, providerErrorIsNotFound, sanitizeError } from "./errors.mjs";
+//#region src/sandbox/error.ts
+var error_exports = /* @__PURE__ */ __exportAll({
+	SandboxProviderError: () => SandboxProviderError,
+	makeRedactor: () => makeRedactor,
+	providerError: () => providerError,
+	providerErrorCause: () => providerErrorCause,
+	providerErrorIsNotFound: () => providerErrorIsNotFound,
+	sanitizeError: () => sanitizeError
+});
+//#endregion
+export { SandboxProviderError, makeRedactor, providerError, providerErrorCause, providerErrorIsNotFound, sanitizeError, error_exports as t };
+
+//# sourceMappingURL=error.mjs.map

package/sandbox/error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.mjs","names":[],"sources":["../../../src/sandbox/error.ts"],"sourcesContent":["export {\n\tmakeRedactor,\n\tproviderError,\n\tproviderErrorCause,\n\tproviderErrorIsNotFound,\n\tSandboxProviderError,\n\tsanitizeError,\n} from \"./errors.ts\";\nexport type { Redactor } from \"./errors.ts\";\n"],"mappings":""}

package/sandbox/errors.d.mts

@@ -0,0 +1,2 @@
+import { $ as SandboxTransitionConflictError, B as SandboxDriverLoadError, G as SandboxMustBeStoppedError, H as SandboxDriverNotRegisteredError, I as Redactor, J as SandboxReadError, K as SandboxNotFoundError, L as SandboxBusyError, Q as SandboxStopError, R as SandboxCreateError, U as SandboxDriverRegistrationError, V as SandboxDriverLoadPhase, W as SandboxMountError, X as SandboxRegisterError, Y as SandboxRefreshError, Z as SandboxRemovedError, at as providerError, ct as sanitizeError, et as SandboxUnavailError, it as makeRedactor, nt as SandboxWakeError, ot as providerErrorCause, q as SandboxProviderError, rt as errors_d_exports, st as providerErrorIsNotFound, tt as SandboxUnsupportedError, z as SandboxDestroyError } from "../io-BYs7hbiY.mjs";
+export { Redactor, SandboxBusyError, SandboxCreateError, SandboxDestroyError, SandboxDriverLoadError, SandboxDriverLoadPhase, SandboxDriverNotRegisteredError, SandboxDriverRegistrationError, errors_d_exports as SandboxError, SandboxMountError, SandboxMustBeStoppedError, SandboxNotFoundError, SandboxProviderError, SandboxReadError, SandboxRefreshError, SandboxRegisterError, SandboxRemovedError, SandboxStopError, SandboxTransitionConflictError, SandboxUnavailError, SandboxUnsupportedError, SandboxWakeError, makeRedactor, providerError, providerErrorCause, providerErrorIsNotFound, sanitizeError };

package/sandbox/errors.mjs

@@ -0,0 +1,160 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ID, PersistedError, Status } from "./instance.mjs";
+import { Schema } from "effect";
+//#region src/sandbox/errors.ts
+var errors_exports = /* @__PURE__ */ __exportAll({
+	SandboxBusyError: () => SandboxBusyError,
+	SandboxDriverLoadError: () => SandboxDriverLoadError,
+	SandboxDriverLoadPhase: () => SandboxDriverLoadPhase,
+	SandboxDriverNotRegisteredError: () => SandboxDriverNotRegisteredError,
+	SandboxDriverRegistrationError: () => SandboxDriverRegistrationError,
+	SandboxError: () => errors_exports,
+	SandboxMustBeStoppedError: () => SandboxMustBeStoppedError,
+	SandboxNotFoundError: () => SandboxNotFoundError,
+	SandboxProviderError: () => SandboxProviderError,
+	SandboxRemovedError: () => SandboxRemovedError,
+	SandboxTransitionConflictError: () => SandboxTransitionConflictError,
+	SandboxUnavailError: () => SandboxUnavailError,
+	SandboxUnsupportedError: () => SandboxUnsupportedError,
+	makeRedactor: () => makeRedactor,
+	providerError: () => providerError,
+	providerErrorCause: () => providerErrorCause,
+	providerErrorIsNotFound: () => providerErrorIsNotFound,
+	sanitizeError: () => sanitizeError
+});
+/**
+* Lifecycle errors are confined to the control plane. Once a mount succeeds,
+* consumers continue to see only FileSystemError and ShellError.
+*/
+var SandboxNotFoundError = class extends Schema.TaggedError()("SandboxNotFoundError", { id: ID }) {};
+var SandboxDriverNotRegisteredError = class extends Schema.TaggedError()("SandboxDriverNotRegisteredError", {
+	driver: Schema.String,
+	registered: Schema.optional(Schema.Array(Schema.String))
+}) {};
+var SandboxDriverRegistrationError = class extends Schema.TaggedError()("SandboxDriverRegistrationError", {
+	driver: Schema.String,
+	reason: Schema.String
+}) {};
+const SandboxDriverLoadPhase = Schema.Literals([
+	"resolve",
+	"import",
+	"module",
+	"api-version",
+	"options",
+	"factory",
+	"registration"
+]);
+var SandboxDriverLoadError = class extends Schema.TaggedError()("SandboxDriverLoadError", {
+	specifier: Schema.String,
+	phase: SandboxDriverLoadPhase,
+	driver: Schema.optional(Schema.String),
+	reason: Schema.String
+}) {};
+var SandboxBusyError = class extends Schema.TaggedError()("SandboxBusyError", {
+	id: ID,
+	refCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}) {};
+var SandboxMustBeStoppedError = class extends Schema.TaggedError()("SandboxMustBeStoppedError", {
+	id: ID,
+	status: Status
+}) {};
+var SandboxRemovedError = class extends Schema.TaggedError()("SandboxRemovedError", {
+	id: ID,
+	removedAt: Schema.optional(Schema.DateTimeUtc)
+}) {};
+var SandboxUnavailError = class extends Schema.TaggedError()("SandboxUnavailError", {
+	id: ID,
+	reason: Schema.String
+}) {};
+var SandboxUnsupportedError = class extends Schema.TaggedError()("SandboxUnsupportedError", {
+	id: Schema.optional(ID),
+	driver: Schema.String,
+	operation: Schema.String
+}) {};
+var SandboxTransitionConflictError = class extends Schema.TaggedError()("SandboxTransitionConflictError", {
+	id: ID,
+	expected: Schema.Array(Status),
+	actual: Status
+}) {};
+/**
+* A lifecycle failure safe to serialize, persist, or log.
+*
+* The raw SDK defect is deliberately absent from the schema. It is retained on
+* a non-enumerable symbol by {@link providerError}, so Effect's default
+* formatting and JSON serialization cannot expose credentials nested in it.
+*/
+var SandboxProviderError = class extends Schema.TaggedError()("SandboxProviderError", {
+	driver: Schema.String,
+	operation: Schema.String,
+	sanitized: PersistedError
+}) {};
+const rawCause = Symbol("@codework/sandbox/provider/error/raw/cause");
+const missingResource = Symbol("@codework/sandbox/provider/error/missing/resource");
+const providerErrorCause = (error) => error[rawCause];
+const providerErrorIsNotFound = (error) => error[missingResource] === true;
+const REDACTED = "<redacted>";
+/**
+* Conservative text redaction shared by every driver sanitizer.
+*
+* Disclaimer: This can really leak. Its never safe
+*
+* Configured secrets are removed exactly. Common authorization/header and URL
+* query shapes are masked as a second line of defence for values the caller did
+* not explicitly seed.
+*
+* Note: add support for diff regex as needed.
+*/
+const makeRedactor = (secrets = []) => {
+	const configured = [...secrets].filter((secret) => secret.length > 0).sort((a, b) => b.length - a.length);
+	return (value) => {
+		let redacted = value;
+		for (const secret of configured) redacted = redacted.replaceAll(secret, REDACTED);
+		return redacted.replace(/\b(authorization\s*:\s*(?:bearer|basic)\s+)[^\s,;]+/gi, `$1${REDACTED}`).replace(/\b((?:api[-_]?key|token|secret|password)\s*[=:]\s*)[^\s,;&]+/gi, `$1${REDACTED}`).replace(/([?&](?:access_token|api_key|token|secret|password)=)[^&#\s]+/gi, `$1${REDACTED}`).replace(/\b(?:gh[opsu]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g, REDACTED);
+	};
+};
+const errorCode = (cause) => {
+	if (typeof cause !== "object" || cause === null || !("code" in cause)) return void 0;
+	const code = cause.code;
+	return typeof code === "string" || typeof code === "number" ? String(code) : void 0;
+};
+const errorName = (cause) => {
+	if (typeof cause !== "object" || cause === null || !("name" in cause) || typeof cause.name !== "string") return "Error";
+	return cause.name;
+};
+const errorMessage = (cause) => {
+	if (typeof cause === "object" && cause !== null && "message" in cause && typeof cause.message === "string") return cause.message;
+	return String(cause);
+};
+const sanitizeError = (cause, redact = makeRedactor()) => {
+	const code = errorCode(cause);
+	return {
+		name: redact(errorName(cause)),
+		message: redact(errorMessage(cause)),
+		...code === void 0 ? {} : { code: redact(code) }
+	};
+};
+const providerError = (input) => {
+	const redact = input.redact ?? makeRedactor();
+	const error = new SandboxProviderError({
+		driver: input.driver,
+		operation: input.operation,
+		sanitized: (input.sanitize ?? sanitizeError)(input.cause, redact)
+	});
+	Object.defineProperty(error, rawCause, {
+		configurable: false,
+		enumerable: false,
+		value: input.cause,
+		writable: false
+	});
+	Object.defineProperty(error, missingResource, {
+		configurable: false,
+		enumerable: false,
+		value: input.notFound === true,
+		writable: false
+	});
+	return error;
+};
+//#endregion
+export { SandboxBusyError, SandboxDriverLoadError, SandboxDriverLoadPhase, SandboxDriverNotRegisteredError, SandboxDriverRegistrationError, errors_exports as SandboxError, SandboxMustBeStoppedError, SandboxNotFoundError, SandboxProviderError, SandboxRemovedError, SandboxTransitionConflictError, SandboxUnavailError, SandboxUnsupportedError, makeRedactor, providerError, providerErrorCause, providerErrorIsNotFound, sanitizeError };
+
+//# sourceMappingURL=errors.mjs.map

package/sandbox/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":["SandboxInstance.ID","SandboxInstance.Status","SandboxInstance.PersistedError"],"sources":["../../../src/sandbox/errors.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { SandboxInstance } from \"./instance.ts\";\n\n/**\n * Lifecycle errors are confined to the control plane. Once a mount succeeds,\n * consumers continue to see only FileSystemError and ShellError.\n */\nexport class SandboxNotFoundError extends Schema.TaggedError<SandboxNotFoundError>()(\"SandboxNotFoundError\", {\n\tid: SandboxInstance.ID,\n}) {}\n\nexport class SandboxDriverNotRegisteredError extends Schema.TaggedError<SandboxDriverNotRegisteredError>()(\n\t\"SandboxDriverNotRegisteredError\",\n\t{\n\t\tdriver: Schema.String,\n\t\tregistered: Schema.optional(Schema.Array(Schema.String)),\n\t},\n) {}\n\nexport class SandboxDriverRegistrationError extends Schema.TaggedError<SandboxDriverRegistrationError>()(\n\t\"SandboxDriverRegistrationError\",\n\t{\n\t\tdriver: Schema.String,\n\t\treason: Schema.String,\n\t},\n) {}\n\nexport const SandboxDriverLoadPhase = Schema.Literals([\n\t\"resolve\",\n\t\"import\",\n\t\"module\",\n\t\"api-version\",\n\t\"options\",\n\t\"factory\",\n\t\"registration\",\n]);\nexport type SandboxDriverLoadPhase = typeof SandboxDriverLoadPhase.Type;\n\nexport class SandboxDriverLoadError extends Schema.TaggedError<SandboxDriverLoadError>()(\"SandboxDriverLoadError\", {\n\tspecifier: Schema.String,\n\tphase: SandboxDriverLoadPhase,\n\tdriver: Schema.optional(Schema.String),\n\treason: Schema.String,\n}) {}\n\nexport class SandboxBusyError extends Schema.TaggedError<SandboxBusyError>()(\"SandboxBusyError\", {\n\tid: SandboxInstance.ID,\n\trefCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n}) {}\n\nexport class SandboxMustBeStoppedError extends Schema.TaggedError<SandboxMustBeStoppedError>()(\n\t\"SandboxMustBeStoppedError\",\n\t{\n\t\tid: SandboxInstance.ID,\n\t\tstatus: SandboxInstance.Status,\n\t},\n) {}\n\nexport class SandboxRemovedError extends Schema.TaggedError<SandboxRemovedError>()(\"SandboxRemovedError\", {\n\tid: SandboxInstance.ID,\n\tremovedAt: Schema.optional(Schema.DateTimeUtc),\n}) {}\n\nexport class SandboxUnavailError extends Schema.TaggedError<SandboxUnavailError>()(\"SandboxUnavailError\", {\n\tid: SandboxInstance.ID,\n\treason: Schema.String,\n}) {}\n\nexport class SandboxUnsupportedError extends Schema.TaggedError<SandboxUnsupportedError>()(\"SandboxUnsupportedError\", {\n\tid: Schema.optional(SandboxInstance.ID),\n\tdriver: Schema.String,\n\toperation: Schema.String,\n}) {}\n\nexport class SandboxTransitionConflictError extends Schema.TaggedError<SandboxTransitionConflictError>()(\n\t\"SandboxTransitionConflictError\",\n\t{\n\t\tid: SandboxInstance.ID,\n\t\texpected: Schema.Array(SandboxInstance.Status),\n\t\tactual: SandboxInstance.Status,\n\t},\n) {}\n\n/**\n * A lifecycle failure safe to serialize, persist, or log.\n *\n * The raw SDK defect is deliberately absent from the schema. It is retained on\n * a non-enumerable symbol by {@link providerError}, so Effect's default\n * formatting and JSON serialization cannot expose credentials nested in it.\n */\nexport class SandboxProviderError extends Schema.TaggedError<SandboxProviderError>()(\"SandboxProviderError\", {\n\tdriver: Schema.String,\n\toperation: Schema.String,\n\tsanitized: SandboxInstance.PersistedError,\n}) {}\n\nconst rawCause = Symbol(\"@codework/sandbox/provider/error/raw/cause\");\nconst missingResource = Symbol(\"@codework/sandbox/provider/error/missing/resource\");\n\nexport const providerErrorCause = (error: SandboxProviderError): unknown =>\n\t(error as SandboxProviderError & { readonly [rawCause]?: unknown })[rawCause];\n\nexport const providerErrorIsNotFound = (error: SandboxProviderError): boolean =>\n\t(error as SandboxProviderError & { readonly [missingResource]?: boolean })[missingResource] === true;\n\nexport type Redactor = (value: string) => string;\n\nconst REDACTED = \"<redacted>\";\n\n/**\n * Conservative text redaction shared by every driver sanitizer.\n *\n * Disclaimer: This can really leak. Its never safe\n *\n * Configured secrets are removed exactly. Common authorization/header and URL\n * query shapes are masked as a second line of defence for values the caller did\n * not explicitly seed.\n *\n * Note: add support for diff regex as needed.\n */\nexport const makeRedactor = (secrets: Iterable<string> = []): Redactor => {\n\tconst configured = [...secrets].filter((secret) => secret.length > 0).sort((a, b) => b.length - a.length);\n\treturn (value) => {\n\t\tlet redacted = value;\n\t\tfor (const secret of configured) redacted = redacted.replaceAll(secret, REDACTED);\n\t\treturn redacted\n\t\t\t.replace(/\\b(authorization\\s*:\\s*(?:bearer|basic)\\s+)[^\\s,;]+/gi, `$1${REDACTED}`)\n\t\t\t.replace(/\\b((?:api[-_]?key|token|secret|password)\\s*[=:]\\s*)[^\\s,;&]+/gi, `$1${REDACTED}`)\n\t\t\t.replace(/([?&](?:access_token|api_key|token|secret|password)=)[^&#\\s]+/gi, `$1${REDACTED}`)\n\t\t\t.replace(/\\b(?:gh[opsu]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]{20,})\\b/g, REDACTED);\n\t};\n};\n\nconst errorCode = (cause: unknown): string | undefined => {\n\tif (typeof cause !== \"object\" || cause === null || !(\"code\" in cause)) return undefined;\n\tconst code = cause.code;\n\treturn typeof code === \"string\" || typeof code === \"number\" ? String(code) : undefined;\n};\n\nconst errorName = (cause: unknown): string => {\n\tif (typeof cause !== \"object\" || cause === null || !(\"name\" in cause) || typeof cause.name !== \"string\")\n\t\treturn \"Error\";\n\treturn cause.name;\n};\n\nconst errorMessage = (cause: unknown): string => {\n\tif (typeof cause === \"object\" && cause !== null && \"message\" in cause && typeof cause.message === \"string\")\n\t\treturn cause.message;\n\treturn String(cause);\n};\n\nexport const sanitizeError = (cause: unknown, redact: Redactor = makeRedactor()): SandboxInstance.PersistedError => {\n\tconst code = errorCode(cause);\n\treturn {\n\t\tname: redact(errorName(cause)),\n\t\tmessage: redact(errorMessage(cause)),\n\t\t...(code === undefined ? {} : { code: redact(code) }),\n\t};\n};\n\nexport const providerError = (input: {\n\treadonly driver: string;\n\treadonly operation: string;\n\treadonly cause: unknown;\n\treadonly redact?: Redactor;\n\treadonly sanitize?: (cause: unknown, redact: Redactor) => SandboxInstance.PersistedError;\n\treadonly notFound?: boolean;\n}): SandboxProviderError => {\n\tconst redact = input.redact ?? makeRedactor();\n\tconst error = new SandboxProviderError({\n\t\tdriver: input.driver,\n\t\toperation: input.operation,\n\t\tsanitized: (input.sanitize ?? sanitizeError)(input.cause, redact),\n\t});\n\tObject.defineProperty(error, rawCause, {\n\t\tconfigurable: false,\n\t\tenumerable: false,\n\t\tvalue: input.cause,\n\t\twritable: false,\n\t});\n\tObject.defineProperty(error, missingResource, {\n\t\tconfigurable: false,\n\t\tenumerable: false,\n\t\tvalue: input.notFound === true,\n\t\twritable: false,\n\t});\n\treturn error;\n};\n\nexport type SandboxMountError =\n\t| SandboxNotFoundError\n\t| SandboxDriverNotRegisteredError\n\t| SandboxUnavailError\n\t| SandboxRemovedError\n\t| SandboxProviderError;\n\nexport type SandboxCreateError =\n\t| SandboxDriverNotRegisteredError\n\t| SandboxDriverRegistrationError\n\t| SandboxProviderError;\n\nexport type SandboxRegisterError =\n\t| SandboxDriverNotRegisteredError\n\t| SandboxDriverRegistrationError\n\t| SandboxUnsupportedError\n\t| SandboxProviderError;\n\nexport type SandboxReadError = never;\n\nexport type SandboxRefreshError =\n\t| SandboxNotFoundError\n\t| SandboxDriverNotRegisteredError\n\t| SandboxUnavailError\n\t| SandboxUnsupportedError\n\t| SandboxProviderError;\n\nexport type SandboxWakeError = SandboxRefreshError | SandboxRemovedError;\n\nexport type SandboxStopError = SandboxWakeError | SandboxBusyError | SandboxTransitionConflictError;\n\nexport type SandboxDestroyError = SandboxStopError | SandboxMustBeStoppedError;\n\nexport * as SandboxError from \"./errors.ts\";\n"],"mappings":"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"}

package/sandbox/filesystem.d.mts

@@ -0,0 +1,2 @@
+import { a as Provider, c as filesystem_d_exports, d as realpathScripts, f as validateRmOptions, i as OperationUnsupportedError, l as fromProvider, n as FileSystemError, o as RmOptions, p as withCwd, r as Interface, s as Service, t as FileStat, u as isNotFoundError } from "../filesystem-Cp-KapCE.mjs";
+export { FileStat, FileSystemError, Interface, OperationUnsupportedError, Provider, RmOptions, filesystem_d_exports as SandboxFileSystem, Service, fromProvider, isNotFoundError, realpathScripts, validateRmOptions, withCwd };

package/sandbox/filesystem.mjs

@@ -0,0 +1,142 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { posix } from "../posix.mjs";
+import { Context, Effect, Schema } from "effect";
+//#region src/sandbox/filesystem.ts
+var filesystem_exports = /* @__PURE__ */ __exportAll({
+	FileSystemError: () => FileSystemError,
+	OperationUnsupportedError: () => OperationUnsupportedError,
+	SandboxFileSystem: () => filesystem_exports,
+	Service: () => Service,
+	fromProvider: () => fromProvider,
+	isNotFoundError: () => isNotFoundError,
+	realpathScripts: () => realpathScripts,
+	validateRmOptions: () => validateRmOptions,
+	withCwd: () => withCwd
+});
+/**
+* The runtime filesystem contract, independent of any backend.
+*
+* Two surfaces, deliberately:
+* - {@link Provider} is what a backend implements — plain promises that reject,
+*   matching every SDK we wrap.
+* - {@link Interface} is what the harness consumes — Effect with a typed error
+*   channel and tracing spans. {@link fromProvider} bridges the two exactly
+*   once, so no consumer ever writes `Effect.tryPromise` against a filesystem.
+*
+* Implementations:
+* - Local:
+* implement it over a VFS (`./local`);
+* local filesystem use OS primitives; hence have broader filesytem capabilities.
+*
+* - Remote:
+* implement it over a provider (`./remote`).
+* remote filesytems depends on the interface provided by the remote provider; hence can have limited filesytem capabilities.
+*
+* `isFile`/`isDirectory` are required booleans; size, mtime, and isSymbolicLink are omitted when the
+* backend cannot report them — never fabricated.
+*
+* **Paths are POSIX, and the harness is Unix-only (for now!).** Every path uses `/`
+* separators on both the host and inside a sandbox — Windows is not supported,
+* so no translation layer exists. Consumers must use the shared Effect POSIX
+* path implementation, never the platform default, or a host running the harness would
+* impose its own flavour on a remote sandbox's paths. Relative paths resolve
+* against the backend's configured `cwd`.
+*/
+var OperationUnsupportedError = class extends Schema.TaggedError()("OperationUnsupportedError", {
+	operation: Schema.String,
+	message: Schema.String
+}) {};
+/** A backend operation failed. `cause` carries the provider's own rejection. */
+var FileSystemError = class extends Schema.TaggedError()("SandboxFileSystemError", {
+	method: Schema.String,
+	path: Schema.String,
+	cause: Schema.optional(Schema.Defect())
+}) {};
+/** Whether a provider failure means the path itself is definitively absent. */
+const isNotFoundError = (cause) => {
+	const code = cause?.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+};
+/**
+* Shell forms of `realpath` for backends that only expose a process API.
+* `pwd -P` is the portable primitive: directories resolve directly, anything
+* else resolves its parent and keeps the final name as given. Run as
+* `sh -c <script> _ <path>`; try the first, fall back to the second.
+*/
+const realpathScripts = ["cd -- \"$1\" && pwd -P", "cd -- \"$(dirname -- \"$1\")\" && printf '%s/%s' \"$(pwd -P)\" \"$(basename -- \"$1\")\""];
+/** The runtime filesystem service — the live {@link Interface} for the active sandbox. */
+var Service = class extends Context.Service()("@codeworksh/plugin/sandbox/filesystem/Service") {};
+/**
+* Reject `rm` options a provider does not implement, before any mutation. Only
+* `recursive` and `force` are part of the contract; anything else is refused
+* loudly rather than silently ignored.
+*/
+const validateRmOptions = (options, operation = "rm") => Effect.suspend(() => {
+	for (const option of Object.keys(options ?? {})) {
+		if (option === "recursive" || option === "force") continue;
+		return Effect.fail(new OperationUnsupportedError({
+			operation,
+			message: `Unsupported rm option: ${option}`
+		}));
+	}
+	return Effect.void;
+});
+/**
+* Lift a {@link Provider} into the runtime {@link Interface}: one place that
+* converts rejections into {@link FileSystemError}, validates `rm` options,
+* creates missing parents on write, and names a tracing span per operation.
+*/
+const fromProvider = (provider) => {
+	const attempt = (method, path, run) => Effect.tryPromise({
+		try: run,
+		catch: (cause) => new FileSystemError({
+			method,
+			path,
+			cause
+		})
+	});
+	const writeCreatingParents = (path, content) => {
+		const write = attempt("writeFile", path, () => provider.writeFile(path, content));
+		const parent = posix.dirname(path);
+		return write.pipe(Effect.catch(() => attempt("mkdir", parent, () => provider.mkdir(parent, { recursive: true })).pipe(Effect.ignore, Effect.andThen(write))));
+	};
+	return {
+		readFile: Effect.fn("SandboxFileSystem.readFile")((path) => attempt("readFile", path, () => provider.readFile(path))),
+		readFileBuffer: Effect.fn("SandboxFileSystem.readFileBuffer")((path) => attempt("readFileBuffer", path, () => provider.readFileBuffer(path))),
+		writeFile: Effect.fn("SandboxFileSystem.writeFile")(writeCreatingParents),
+		stat: Effect.fn("SandboxFileSystem.stat")((path) => attempt("stat", path, () => provider.stat(path))),
+		...provider.lstat === void 0 ? {} : { lstat: Effect.fn("SandboxFileSystem.lstat")((path) => attempt("lstat", path, () => provider.lstat(path))) },
+		readdir: Effect.fn("SandboxFileSystem.readdir")((path) => attempt("readdir", path, () => provider.readdir(path))),
+		exists: Effect.fn("SandboxFileSystem.exists")((path) => attempt("exists", path, () => provider.exists(path))),
+		mkdir: Effect.fn("SandboxFileSystem.mkdir")((path, options) => attempt("mkdir", path, () => provider.mkdir(path, options))),
+		rm: Effect.fn("SandboxFileSystem.rm")((path, options) => validateRmOptions(options).pipe(Effect.andThen(attempt("rm", path, () => provider.rm(path, options))))),
+		realpath: Effect.fn("SandboxFileSystem.realpath")((path) => attempt("realpath", path, () => provider.realpath(path)))
+	};
+};
+/**
+* Bind a cwd-neutral filesystem to one mount's working directory.
+*
+* The counterpart of `Shell.withCwd`, and the reason relative paths mean the
+* same thing to both: a shared transport stays rooted at the namespace root, so
+* resolution happens here, per mount, rather than inside a VFS whose `chdir` is
+* global state two mounts would fight over.
+*/
+const withCwd = (fs, cwd) => {
+	const at = (path) => posix.resolve(cwd, path);
+	return {
+		readFile: (path) => fs.readFile(at(path)),
+		readFileBuffer: (path) => fs.readFileBuffer(at(path)),
+		writeFile: (path, content) => fs.writeFile(at(path), content),
+		stat: (path) => fs.stat(at(path)),
+		readdir: (path) => fs.readdir(at(path)),
+		exists: (path) => fs.exists(at(path)),
+		mkdir: (path, options) => fs.mkdir(at(path), options),
+		rm: (path, options) => fs.rm(at(path), options),
+		realpath: (path) => fs.realpath(at(path)),
+		...fs.lstat === void 0 ? {} : { lstat: (path) => fs.lstat(at(path)) }
+	};
+};
+//#endregion
+export { FileSystemError, OperationUnsupportedError, filesystem_exports as SandboxFileSystem, Service, fromProvider, isNotFoundError, realpathScripts, validateRmOptions, withCwd };
+
+//# sourceMappingURL=filesystem.mjs.map

package/sandbox/filesystem.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.mjs","names":[],"sources":["../../../src/sandbox/filesystem.ts"],"sourcesContent":["import { Context, Effect, Schema } from \"effect\";\nimport { posix } from \"../posix.ts\";\n\n/**\n * The runtime filesystem contract, independent of any backend.\n *\n * Two surfaces, deliberately:\n * - {@link Provider} is what a backend implements — plain promises that reject,\n *   matching every SDK we wrap.\n * - {@link Interface} is what the harness consumes — Effect with a typed error\n *   channel and tracing spans. {@link fromProvider} bridges the two exactly\n *   once, so no consumer ever writes `Effect.tryPromise` against a filesystem.\n *\n * Implementations:\n * - Local:\n * implement it over a VFS (`./local`);\n * local filesystem use OS primitives; hence have broader filesytem capabilities.\n *\n * - Remote:\n * implement it over a provider (`./remote`).\n * remote filesytems depends on the interface provided by the remote provider; hence can have limited filesytem capabilities.\n *\n * `isFile`/`isDirectory` are required booleans; size, mtime, and isSymbolicLink are omitted when the\n * backend cannot report them — never fabricated.\n *\n * **Paths are POSIX, and the harness is Unix-only (for now!).** Every path uses `/`\n * separators on both the host and inside a sandbox — Windows is not supported,\n * so no translation layer exists. Consumers must use the shared Effect POSIX\n * path implementation, never the platform default, or a host running the harness would\n * impose its own flavour on a remote sandbox's paths. Relative paths resolve\n * against the backend's configured `cwd`.\n */\n\nexport class OperationUnsupportedError extends Schema.TaggedError<OperationUnsupportedError>()(\n\t\"OperationUnsupportedError\",\n\t{\n\t\toperation: Schema.String,\n\t\tmessage: Schema.String,\n\t},\n) {}\n\n/** A backend operation failed. `cause` carries the provider's own rejection. */\nexport class FileSystemError extends Schema.TaggedError<FileSystemError>()(\"SandboxFileSystemError\", {\n\tmethod: Schema.String,\n\tpath: Schema.String,\n\tcause: Schema.optional(Schema.Defect()),\n}) {}\n\nexport interface FileStat {\n\treadonly isFile: boolean;\n\treadonly isDirectory: boolean;\n\treadonly isSymbolicLink?: boolean;\n\treadonly size?: number;\n\treadonly mtime?: Date;\n}\n\nexport interface RmOptions {\n\treadonly recursive?: boolean;\n\treadonly force?: boolean;\n}\n\n/** Whether a provider failure means the path itself is definitively absent. */\nexport const isNotFoundError = (cause: unknown) => {\n\tconst code = (cause as NodeJS.ErrnoException | undefined)?.code;\n\treturn code === \"ENOENT\" || code === \"ENOTDIR\";\n};\n\n/**\n * Shell forms of `realpath` for backends that only expose a process API.\n * `pwd -P` is the portable primitive: directories resolve directly, anything\n * else resolves its parent and keeps the final name as given. Run as\n * `sh -c <script> _ <path>`; try the first, fall back to the second.\n */\nexport const realpathScripts = [\n\t'cd -- \"$1\" && pwd -P',\n\t'cd -- \"$(dirname -- \"$1\")\" && printf \\'%s/%s\\' \"$(pwd -P)\" \"$(basename -- \"$1\")\"',\n] as const;\n\n/**\n * The backend-facing contract. Backends author plain promises and let them\n * reject; {@link fromProvider} turns rejections into typed failures.\n */\nexport interface Provider {\n\treadonly readFile: (path: string) => Promise<string>;\n\treadonly readFileBuffer: (path: string) => Promise<Uint8Array>;\n\t/**\n\t * Write the file. Parents may be missing — do not create them here;\n\t * {@link fromProvider} owns that guarantee for every backend.\n\t */\n\treadonly writeFile: (path: string, content: string | Uint8Array) => Promise<void>;\n\treadonly stat: (path: string) => Promise<FileStat>;\n\treadonly readdir: (path: string) => Promise<string[]>;\n\treadonly exists: (path: string) => Promise<boolean>;\n\treadonly mkdir: (path: string, options?: { recursive?: boolean }) => Promise<void>;\n\treadonly rm: (path: string, options?: RmOptions) => Promise<void>;\n\t/** Canonical absolute path with symlinks resolved; rejects when the path does not exist. */\n\treadonly realpath: (path: string) => Promise<string>;\n\t/**\n\t * Metadata for the directory entry itself rather than a symlink's target.\n\t * Optional: a backend whose `stat` has mixed symlink semantics implements it\n\t * so symlink identity is asked for explicitly, never inferred.\n\t */\n\treadonly lstat?: (path: string) => Promise<FileStat>;\n}\n\n/**\n * The consumer-facing contract. `exists` distinguishes \"absent\" from \"could not\n * tell\": a backend failure is a typed failure, not `false`, so a caller acting\n * on absence never acts on a network blip. Use `SandboxFs.existsOrFalse` where\n * a best-effort answer really is wanted.\n */\nexport interface Interface {\n\treadonly readFile: (path: string) => Effect.Effect<string, FileSystemError>;\n\treadonly readFileBuffer: (path: string) => Effect.Effect<Uint8Array, FileSystemError>;\n\t/** Creates missing parent directories, on every backend. */\n\treadonly writeFile: (path: string, content: string | Uint8Array) => Effect.Effect<void, FileSystemError>;\n\treadonly stat: (path: string) => Effect.Effect<FileStat, FileSystemError>;\n\treadonly readdir: (path: string) => Effect.Effect<string[], FileSystemError>;\n\treadonly exists: (path: string) => Effect.Effect<boolean, FileSystemError>;\n\treadonly mkdir: (path: string, options?: { recursive?: boolean }) => Effect.Effect<void, FileSystemError>;\n\treadonly rm: (path: string, options?: RmOptions) => Effect.Effect<void, FileSystemError | OperationUnsupportedError>;\n\t/** Canonical absolute path with symlinks resolved; fails when the path does not exist. */\n\treadonly realpath: (path: string) => Effect.Effect<string, FileSystemError>;\n\t// `lstat` is present only when the backend supports it; check before calling.\n\treadonly lstat?: (path: string) => Effect.Effect<FileStat, FileSystemError>;\n}\n\n/** The runtime filesystem service — the live {@link Interface} for the active sandbox. */\nexport class Service extends Context.Service<Service, Interface>()(\"@codeworksh/plugin/sandbox/filesystem/Service\") {}\n\n/**\n * Reject `rm` options a provider does not implement, before any mutation. Only\n * `recursive` and `force` are part of the contract; anything else is refused\n * loudly rather than silently ignored.\n */\nexport const validateRmOptions = (\n\toptions: RmOptions | undefined,\n\toperation = \"rm\",\n): Effect.Effect<void, OperationUnsupportedError> =>\n\tEffect.suspend(() => {\n\t\tfor (const option of Object.keys((options ?? {}) as Record<string, unknown>)) {\n\t\t\tif (option === \"recursive\" || option === \"force\") continue;\n\t\t\treturn Effect.fail(new OperationUnsupportedError({ operation, message: `Unsupported rm option: ${option}` }));\n\t\t}\n\t\treturn Effect.void;\n\t});\n\n/**\n * Lift a {@link Provider} into the runtime {@link Interface}: one place that\n * converts rejections into {@link FileSystemError}, validates `rm` options,\n * creates missing parents on write, and names a tracing span per operation.\n */\nexport const fromProvider = (provider: Provider): Interface => {\n\tconst attempt = <A>(method: string, path: string, run: () => Promise<A>) =>\n\t\tEffect.tryPromise({ try: run, catch: (cause) => new FileSystemError({ method, path, cause }) });\n\n\t// The parent-creation guarantee, installed once for every backend instead of\n\t// re-implemented per provider: anything that reaches `Interface` reaches it\n\t// through here, so a backend cannot forget it.\n\t//\n\t// Lazy by design — try the write first, so the happy path stays a single call\n\t// and no remote backend pays a round-trip per write. A failure is usually a\n\t// missing parent, so create it and retry once. The mkdir's own error is\n\t// dropped on purpose: when the write failed for some other reason (EACCES,\n\t// EROFS, a dropped connection), the retry reproduces it, and *that* is the\n\t// failure the caller must see rather than a misleading mkdir error standing\n\t// in for it.\n\tconst writeCreatingParents = (path: string, content: string | Uint8Array) => {\n\t\tconst write = attempt(\"writeFile\", path, () => provider.writeFile(path, content));\n\t\tconst parent = posix.dirname(path);\n\t\treturn write.pipe(\n\t\t\tEffect.catch(() =>\n\t\t\t\tattempt(\"mkdir\", parent, () => provider.mkdir(parent, { recursive: true })).pipe(\n\t\t\t\t\tEffect.ignore,\n\t\t\t\t\tEffect.andThen(write),\n\t\t\t\t),\n\t\t\t),\n\t\t);\n\t};\n\n\treturn {\n\t\treadFile: Effect.fn(\"SandboxFileSystem.readFile\")((path: string) =>\n\t\t\tattempt(\"readFile\", path, () => provider.readFile(path)),\n\t\t),\n\t\treadFileBuffer: Effect.fn(\"SandboxFileSystem.readFileBuffer\")((path: string) =>\n\t\t\tattempt(\"readFileBuffer\", path, () => provider.readFileBuffer(path)),\n\t\t),\n\t\twriteFile: Effect.fn(\"SandboxFileSystem.writeFile\")(writeCreatingParents),\n\t\tstat: Effect.fn(\"SandboxFileSystem.stat\")((path: string) => attempt(\"stat\", path, () => provider.stat(path))),\n\t\t// carried through only when the backend actually implements it\n\t\t...(provider.lstat === undefined\n\t\t\t? {}\n\t\t\t: {\n\t\t\t\t\tlstat: Effect.fn(\"SandboxFileSystem.lstat\")((path: string) =>\n\t\t\t\t\t\tattempt(\"lstat\", path, () => provider.lstat!(path)),\n\t\t\t\t\t),\n\t\t\t\t}),\n\t\treaddir: Effect.fn(\"SandboxFileSystem.readdir\")((path: string) =>\n\t\t\tattempt(\"readdir\", path, () => provider.readdir(path)),\n\t\t),\n\t\t// A backend that cannot answer fails; it does not report \"absent\". A\n\t\t// caller acting on absence — deleting a record, say — must not be told\n\t\t// the path is gone because a token expired or a request timed out.\n\t\texists: Effect.fn(\"SandboxFileSystem.exists\")((path: string) =>\n\t\t\tattempt(\"exists\", path, () => provider.exists(path)),\n\t\t),\n\t\tmkdir: Effect.fn(\"SandboxFileSystem.mkdir\")((path: string, options?: { recursive?: boolean }) =>\n\t\t\tattempt(\"mkdir\", path, () => provider.mkdir(path, options)),\n\t\t),\n\t\trm: Effect.fn(\"SandboxFileSystem.rm\")((path: string, options?: RmOptions) =>\n\t\t\tvalidateRmOptions(options).pipe(Effect.andThen(attempt(\"rm\", path, () => provider.rm(path, options)))),\n\t\t),\n\t\trealpath: Effect.fn(\"SandboxFileSystem.realpath\")((path: string) =>\n\t\t\tattempt(\"realpath\", path, () => provider.realpath(path)),\n\t\t),\n\t};\n};\n\n/**\n * Bind a cwd-neutral filesystem to one mount's working directory.\n *\n * The counterpart of `Shell.withCwd`, and the reason relative paths mean the\n * same thing to both: a shared transport stays rooted at the namespace root, so\n * resolution happens here, per mount, rather than inside a VFS whose `chdir` is\n * global state two mounts would fight over.\n */\nexport const withCwd = (fs: Interface, cwd: string): Interface => {\n\tconst at = (path: string) => posix.resolve(cwd, path);\n\treturn {\n\t\treadFile: (path) => fs.readFile(at(path)),\n\t\treadFileBuffer: (path) => fs.readFileBuffer(at(path)),\n\t\twriteFile: (path, content) => fs.writeFile(at(path), content),\n\t\tstat: (path) => fs.stat(at(path)),\n\t\treaddir: (path) => fs.readdir(at(path)),\n\t\texists: (path) => fs.exists(at(path)),\n\t\tmkdir: (path, options) => fs.mkdir(at(path), options),\n\t\trm: (path, options) => fs.rm(at(path), options),\n\t\trealpath: (path) => fs.realpath(at(path)),\n\t\t// carried through only when the backend implements it, so a caller can\n\t\t// still detect absence by checking the property\n\t\t...(fs.lstat === undefined ? {} : { lstat: (path: string) => fs.lstat!(at(path)) }),\n\t};\n};\n\nexport * as SandboxFileSystem from \"./filesystem.ts\";\n"],"mappings":"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"}

package/sandbox/instance.d.mts

@@ -0,0 +1,2 @@
+import { St as toField, _t as fromField, bt as mountable, dt as Kind, ft as Ownership, gt as fromColumn, ht as Usage, lt as ID, mt as Status, pt as PersistedError, ut as Info, vt as instance_d_exports, xt as toColumn, yt as isMountable } from "../io-BYs7hbiY.mjs";
+export { ID, Info, Kind, Ownership, PersistedError, instance_d_exports as SandboxInstance, Status, Usage, fromColumn, fromField, isMountable, mountable, toColumn, toField };