@codeworksh/plugin 0.0.1-dev.20260922103030

package/io-BYs7hbiY.d.mts

@@ -0,0 +1,497 @@
+import { c as filesystem_d_exports, s as Service } from "./filesystem-Cp-KapCE.mjs";
+import { i as Shell$1 } from "./shell-CZ6Y4lNU.mjs";
+import { Context, Effect, Layer, Option, Schema } from "effect";
+declare namespace instance_d_exports {
+  export { ID, Info, Kind, Ownership, PersistedError, instance_d_exports as SandboxInstance, Status, Usage, fromColumn, fromField, isMountable, mountable, toColumn, 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.
+ */
+declare const ID: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+  /**
+   * 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: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  /** A fresh identity for a namespace nothing has named yet. */
+  create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+};
+type ID = typeof ID.Type;
+/**
+ * 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`.
+ */
+declare const toColumn: (id: ID) => string | null;
+declare const fromColumn: (value: string | null) => ID;
+/**
+ * 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`.
+ */
+declare const toField: (id: ID) => Option.Option<ID>;
+declare const fromField: (value: Option.Option<ID>) => ID;
+/**
+ * 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.
+ */
+declare const Kind: Schema.Literals<readonly ["local", "virtual", "remote"]>;
+type Kind = typeof Kind.Type;
+declare const Ownership: Schema.Literals<readonly ["managed", "external"]>;
+type Ownership = typeof Ownership.Type;
+/**
+ * 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.
+ */
+declare const Status: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
+type Status = typeof Status.Type;
+/**
+ * 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.
+ */
+declare const mountable: ReadonlySet<Status>;
+declare const isMountable: (status: Status) => boolean;
+/**
+ * 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.
+ */
+declare const Usage: Schema.Literals<readonly ["idle", "busy", "pinned"]>;
+type Usage = typeof Usage.Type;
+/** Sanitized driver failure. The only error shape allowed to be persisted or logged. */
+declare const PersistedError: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly message: Schema.String;
+  readonly code: Schema.optional<Schema.String>;
+}>;
+type PersistedError = typeof PersistedError.Type;
+/** Durable metadata, safe to return and persist. Assembled by the control plane. */
+interface Info {
+  readonly id: ID;
+  readonly driver: Name;
+  readonly kind: Kind;
+  readonly providerResourceId: Option.Option<string>;
+  readonly ownership: Ownership;
+  readonly status: Status;
+  readonly usage: Usage;
+  /** References held by *this* control plane. Process-local; see the transport cache. */
+  readonly refCount: number;
+  readonly providerStatus: Option.Option<string>;
+  readonly metadata: Readonly<Record<string, string>>;
+  readonly lastError: Option.Option<PersistedError>;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+  readonly stateObservedAt: Date;
+  readonly lastMountedAt: Option.Option<Date>;
+  readonly lastUnmountedAt: Option.Option<Date>;
+  readonly lastUsedAt: Option.Option<Date>;
+  readonly removedAt: Option.Option<Date>;
+}
+declare namespace errors_d_exports {
+  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 };
+}
+declare const SandboxNotFoundError_base: Schema.Class<SandboxNotFoundError, Schema.TaggedStruct<"SandboxNotFoundError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Lifecycle errors are confined to the control plane. Once a mount succeeds,
+ * consumers continue to see only FileSystemError and ShellError.
+ */
+declare class SandboxNotFoundError extends SandboxNotFoundError_base {}
+declare const SandboxDriverNotRegisteredError_base: Schema.Class<SandboxDriverNotRegisteredError, Schema.TaggedStruct<"SandboxDriverNotRegisteredError", {
+  readonly driver: Schema.String;
+  readonly registered: Schema.optional<Schema.$Array<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDriverNotRegisteredError extends SandboxDriverNotRegisteredError_base {}
+declare const SandboxDriverRegistrationError_base: Schema.Class<SandboxDriverRegistrationError, Schema.TaggedStruct<"SandboxDriverRegistrationError", {
+  readonly driver: Schema.String;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDriverRegistrationError extends SandboxDriverRegistrationError_base {}
+declare const SandboxDriverLoadPhase: Schema.Literals<readonly ["resolve", "import", "module", "api-version", "options", "factory", "registration"]>;
+type SandboxDriverLoadPhase = typeof SandboxDriverLoadPhase.Type;
+declare const SandboxDriverLoadError_base: Schema.Class<SandboxDriverLoadError, Schema.TaggedStruct<"SandboxDriverLoadError", {
+  readonly specifier: Schema.String;
+  readonly phase: Schema.Literals<readonly ["resolve", "import", "module", "api-version", "options", "factory", "registration"]>;
+  readonly driver: Schema.optional<Schema.String>;
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxDriverLoadError extends SandboxDriverLoadError_base {}
+declare const SandboxBusyError_base: Schema.Class<SandboxBusyError, Schema.TaggedStruct<"SandboxBusyError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly refCount: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxBusyError extends SandboxBusyError_base {}
+declare const SandboxMustBeStoppedError_base: Schema.Class<SandboxMustBeStoppedError, Schema.TaggedStruct<"SandboxMustBeStoppedError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly status: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxMustBeStoppedError extends SandboxMustBeStoppedError_base {}
+declare const SandboxRemovedError_base: Schema.Class<SandboxRemovedError, Schema.TaggedStruct<"SandboxRemovedError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly removedAt: Schema.optional<Schema.DateTimeUtc>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxRemovedError extends SandboxRemovedError_base {}
+declare const SandboxUnavailError_base: Schema.Class<SandboxUnavailError, Schema.TaggedStruct<"SandboxUnavailError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxUnavailError extends SandboxUnavailError_base {}
+declare const SandboxUnsupportedError_base: Schema.Class<SandboxUnsupportedError, Schema.TaggedStruct<"SandboxUnsupportedError", {
+  readonly id: Schema.optional<Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  }>;
+  readonly driver: Schema.String;
+  readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxUnsupportedError extends SandboxUnsupportedError_base {}
+declare const SandboxTransitionConflictError_base: Schema.Class<SandboxTransitionConflictError, Schema.TaggedStruct<"SandboxTransitionConflictError", {
+  readonly id: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly expected: Schema.$Array<Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>>;
+  readonly actual: Schema.Literals<readonly ["provisioning", "online", "offline", "suspending", "removing", "removed", "unavail", "faulted"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class SandboxTransitionConflictError extends SandboxTransitionConflictError_base {}
+declare const SandboxProviderError_base: Schema.Class<SandboxProviderError, Schema.TaggedStruct<"SandboxProviderError", {
+  readonly driver: Schema.String;
+  readonly operation: Schema.String;
+  readonly sanitized: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly message: Schema.String;
+    readonly code: Schema.optional<Schema.String>;
+  }>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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.
+ */
+declare class SandboxProviderError extends SandboxProviderError_base {}
+declare const providerErrorCause: (error: SandboxProviderError) => unknown;
+declare const providerErrorIsNotFound: (error: SandboxProviderError) => boolean;
+type Redactor = (value: string) => string;
+/**
+ * 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.
+ */
+declare const makeRedactor: (secrets?: Iterable<string>) => Redactor;
+declare const sanitizeError: (cause: unknown, redact?: Redactor) => PersistedError;
+declare const providerError: (input: {
+  readonly driver: string;
+  readonly operation: string;
+  readonly cause: unknown;
+  readonly redact?: Redactor;
+  readonly sanitize?: (cause: unknown, redact: Redactor) => PersistedError;
+  readonly notFound?: boolean;
+}) => SandboxProviderError;
+type SandboxMountError = SandboxNotFoundError | SandboxDriverNotRegisteredError | SandboxUnavailError | SandboxRemovedError | SandboxProviderError;
+type SandboxCreateError = SandboxDriverNotRegisteredError | SandboxDriverRegistrationError | SandboxProviderError;
+type SandboxRegisterError = SandboxDriverNotRegisteredError | SandboxDriverRegistrationError | SandboxUnsupportedError | SandboxProviderError;
+type SandboxReadError = never;
+type SandboxRefreshError = SandboxNotFoundError | SandboxDriverNotRegisteredError | SandboxUnavailError | SandboxUnsupportedError | SandboxProviderError;
+type SandboxWakeError = SandboxRefreshError | SandboxRemovedError;
+type SandboxStopError = SandboxWakeError | SandboxBusyError | SandboxTransitionConflictError;
+type SandboxDestroyError = SandboxStopError | SandboxMustBeStoppedError;
+declare namespace driver_d_exports {
+  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 };
+}
+/** Version of the loadable sandbox-driver module ABI. */
+declare const apiVersion: 1;
+type ApiVersion = typeof apiVersion;
+/** Open driver identity. Adding a driver never extends a union in core. */
+declare const Name: Schema.brand<Schema.String, "SandboxDriver.Name">;
+type Name = typeof Name.Type;
+/** A path whose coordinate system is the mounted namespace. */
+declare const AbsolutePath: Schema.brand<Schema.String, "SandboxDriver.AbsolutePath">;
+type AbsolutePath = typeof AbsolutePath.Type;
+declare const RuntimeConfigBase: Schema.Struct<{
+  readonly defaultCwd: Schema.brand<Schema.String, "SandboxDriver.AbsolutePath">;
+}>;
+interface RuntimeConfigBase extends Schema.Schema.Type<typeof RuntimeConfigBase> {}
+interface Capabilities {
+  readonly inspect: boolean;
+  readonly reattach: boolean;
+  readonly wake: boolean;
+  readonly stop: boolean;
+  readonly destroy: boolean;
+  readonly cancels: boolean;
+}
+interface Observed {
+  readonly status: Status;
+  readonly providerStatus?: string | undefined;
+  readonly metadata?: Readonly<Record<string, string>> | undefined;
+}
+interface Provisioned<RuntimeConfig extends RuntimeConfigBase> {
+  readonly providerResourceId?: string | undefined;
+  readonly providerStatus?: string | undefined;
+  readonly runtimeConfig: RuntimeConfig;
+  readonly metadata?: Readonly<Record<string, string>> | undefined;
+}
+interface RuntimeInput<RuntimeConfig extends RuntimeConfigBase> {
+  readonly id: ID;
+  readonly providerResourceId: Option.Option<string>;
+  readonly runtimeConfig: RuntimeConfig;
+}
+interface Driver<CreateConfig, RuntimeConfig extends RuntimeConfigBase> {
+  readonly name: Name;
+  readonly kind: Exclude<Kind, "local">;
+  readonly capabilities: Capabilities;
+  readonly createConfigCodec: Schema.Codec<CreateConfig, unknown>;
+  readonly runtimeConfigCodec: Schema.Codec<RuntimeConfig, unknown>;
+  readonly create: (input: {
+    readonly instanceId: ID;
+    readonly config: CreateConfig;
+  }) => Effect.Effect<Provisioned<RuntimeConfig>, SandboxProviderError>;
+  readonly runtimeConfigFor?: ((input: {
+    readonly providerResourceId: string;
+    readonly overrides?: Partial<RuntimeConfig> | undefined;
+  }) => Effect.Effect<RuntimeConfig, SandboxProviderError>) | undefined;
+  readonly attach: (input: RuntimeInput<RuntimeConfig>) => Layer.Layer<FileSystem | Shell, SandboxProviderError>;
+  readonly inspect?: (input: RuntimeInput<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly wake?: (input: RuntimeInput<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly stop?: (input: RuntimeInput<RuntimeConfig>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly destroy?: (input: RuntimeInput<RuntimeConfig>) => Effect.Effect<void, SandboxProviderError>;
+}
+type Definition<CreateConfig, RuntimeConfig extends RuntimeConfigBase> = Pick<Driver<CreateConfig, RuntimeConfig>, "name" | "createConfigCodec" | "runtimeConfigCodec">;
+/** Registry-only erased shape. Driver authors construct it via {@link driver}. */
+interface Registered {
+  readonly name: Name;
+  readonly kind: Exclude<Kind, "local">;
+  readonly capabilities: Capabilities;
+  readonly createConfigCodec: Schema.Codec<unknown, unknown>;
+  readonly runtimeConfigCodec: Schema.Codec<RuntimeConfigBase, unknown>;
+  readonly create: (input: {
+    readonly instanceId: ID;
+    readonly config: unknown;
+  }) => Effect.Effect<Provisioned<RuntimeConfigBase>, SandboxProviderError>;
+  readonly runtimeConfigFor?: ((input: {
+    readonly providerResourceId: string;
+    readonly overrides?: Readonly<Record<string, unknown>> | undefined;
+  }) => Effect.Effect<RuntimeConfigBase, SandboxProviderError>) | undefined;
+  readonly attach: (input: RuntimeInput<RuntimeConfigBase>) => Layer.Layer<FileSystem | Shell, SandboxProviderError>;
+  readonly inspect?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly wake?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly stop?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<Observed, SandboxProviderError>;
+  readonly destroy?: (input: RuntimeInput<RuntimeConfigBase>) => Effect.Effect<void, SandboxProviderError>;
+}
+declare const erase: <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(value: Driver<CreateConfig, RuntimeConfig>) => Registered;
+type Source = "core" | "builtin" | "package" | "file";
+interface Registration {
+  readonly registered: Registered;
+  readonly apiVersion: ApiVersion;
+  readonly source: Source;
+}
+interface Module<Options> {
+  readonly apiVersion: ApiVersion;
+  readonly name: Name;
+  readonly options: Schema.Codec<Options, unknown>;
+  readonly make: (options: Options) => Registration;
+}
+interface ModuleDefinition<Options> {
+  readonly apiVersion: ApiVersion;
+  readonly name: string | Name;
+  readonly options: Schema.Codec<Options, unknown>;
+  readonly make: (options: Options) => Registration;
+}
+/** Define the default export of a loadable sandbox package. */
+declare const defineModule: <Options>(value: ModuleDefinition<Options>) => Module<Options>;
+/** Construct a driver and its registry contribution. */
+declare const driver: <CreateConfig, RuntimeConfig extends RuntimeConfigBase>(value: Driver<CreateConfig, RuntimeConfig>) => Driver<CreateConfig, RuntimeConfig> & Registration;
+/** Attach trusted origin metadata without changing the driver implementation. */
+declare const withSource: (registration: Registration, source: Source) => Registration;
+declare namespace io_d_exports {
+  export { Current, FileSystem, Identity, Layer$1 as Layer, Provides, io_d_exports as SandboxIO, Shell, host, hostLayer, identityLayer, mount, remote, resolveMountCwd, 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.
+ */
+declare const FileSystem: typeof Service;
+type FileSystem = Service;
+/** The shell tag. Re-exported here so consumers import one namespace. */
+declare const Shell: typeof Shell$1;
+type Shell = Shell$1;
+/**
+ * What a mount sees: immutable identity, plus the working directory resolved for
+ * *this* mount.
+ *
+ * Nothing mutable belongs here. `status`, `usage`, and reference counts all
+ * change while a mount is open, so a mount-time snapshot of them would be wrong
+ * by construction — runtime code that needs live management state asks the
+ * control plane. The driver's own resource locator is likewise absent: consumers
+ * never parse a Vercel name or a Daytona id.
+ */
+interface Identity {
+  readonly id: ID;
+  readonly driver: Name;
+  readonly kind: Kind;
+  /** Absolute, and always a path in *this* namespace. */
+  readonly cwd: string;
+}
+declare const Current_base: Context.ServiceClass<Current, "@codeworksh/plugin/sandbox/io/Current", Identity>;
+/** Identity and working directory of the current mount. */
+declare class Current extends Current_base {}
+/** Everything a mount provides. */
+type Provides = Current | Service | Shell$1;
+/** A built mount. */
+type Layer$1<E = never, RIn = never> = Layer.Layer<Provides, E, RIn>;
+/**
+ * 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`).
+ */
+declare const resolveMountCwd: (defaultCwd: string, cwd?: string) => string;
+/**
+ * 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.
+ */
+declare const mount: (identity: Identity) => Layer.Layer<Provides, never, Service | Shell$1>;
+/**
+ * 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.
+ */
+declare const identityLayer: (identity: Identity) => Layer.Layer<Current, never, never>;
+/** The host identity alone. See {@link identityLayer}. */
+declare const hostLayer: (cwd: string) => Layer.Layer<Current, never, never>;
+/**
+ * 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.
+ */
+declare const host: (cwd: string) => Identity;
+/**
+ * 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.
+ */
+declare const virtual: (input: {
+  readonly driver: string;
+  readonly id?: ID;
+  readonly defaultCwd?: string;
+  readonly cwd?: string;
+}) => Identity;
+/**
+ * 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.
+ */
+declare const remote: (input: {
+  readonly driver: string;
+  readonly id: ID;
+  /** Namespace-intrinsic default supplied or discovered by the driver. */
+  readonly defaultCwd: string;
+  readonly cwd?: string;
+}) => Identity;
+//#endregion
+export { SandboxTransitionConflictError as $, apiVersion as A, SandboxDriverLoadError as B, Observed as C, RuntimeConfigBase as D, Registration as E, withSource as F, SandboxMustBeStoppedError as G, SandboxDriverNotRegisteredError as H, Redactor as I, SandboxReadError as J, SandboxNotFoundError as K, SandboxBusyError as L, driver as M, driver_d_exports as N, RuntimeInput as O, erase as P, SandboxStopError as Q, SandboxCreateError as R, Name as S, toField as St, Registered as T, SandboxDriverRegistrationError as U, SandboxDriverLoadPhase as V, SandboxMountError as W, SandboxRegisterError as X, SandboxRefreshError as Y, SandboxRemovedError as Z, Capabilities as _, fromField as _t, Provides as a, providerError as at, Module as b, mountable as bt, hostLayer as c, sanitizeError as ct, mount as d, Kind as dt, SandboxUnavailError as et, remote as f, Ownership as ft, ApiVersion as g, fromColumn as gt, AbsolutePath as h, Usage as ht, Layer$1 as i, makeRedactor as it, defineModule as j, Source as k, identityLayer as l, ID as lt, virtual as m, Status as mt, FileSystem as n, SandboxWakeError as nt, Shell as o, providerErrorCause as ot, resolveMountCwd as p, PersistedError as pt, SandboxProviderError as q, Identity as r, errors_d_exports as rt, host as s, providerErrorIsNotFound as st, Current as t, SandboxUnsupportedError as tt, io_d_exports as u, Info as ut, Definition as v, instance_d_exports as vt, Provisioned as w, ModuleDefinition as x, toColumn as xt, Driver as y, isMountable as yt, SandboxDestroyError as z };
+//# sourceMappingURL=io-BYs7hbiY.d.mts.map

package/location-D4hAfuXF.d.mts

@@ -0,0 +1,61 @@
+import { i as project_d_exports, n as Info$1 } from "./project-CLGsIFD-.mjs";
+import { a as space_d_exports, n as Info$2 } from "./space-CR-9UxdT.mjs";
+import { Context, Schema } from "effect";
+//#region src/location.d.ts
+/**
+ * Where work happens: a directory inside a space.
+ *
+ * The pair (space, directory) is the key. A path alone does not name a place —
+ * `/app/repo` on the host and `/app/repo` inside a remote sandbox are different
+ * trees wearing the same spelling — so the space carries the env and the
+ * root it lives under (`space.location`), and `directory` is the absolute cwd
+ * equal to or beneath that root. Sessions sharing a space share the project;
+ * worktree relationships stay a Project concern beneath it.
+ *
+ * **Both halves come from the mount, so `Ref` is overrides and nothing else.**
+ * A Location is a directory *within* a mounted namespace — the mount has to be
+ * resolved first, the way a volume is mounted before any path on it means
+ * anything — and once it is, the namespace and the working directory are already
+ * in scope. Re-declaring them would be two spellings of one value, free to drift;
+ * a Location pointing somewhere its own shell is not becomes unrepresentable
+ * rather than merely avoided by discipline.
+ *
+ * Only the shape and the service tag live here. Building one needs Project, Space, Repo and Git,
+ * which belong to the harness; a plugin receives a resolved `Info` on its context and asks for
+ * {@link Service} when it needs the live one.
+ */
+declare const Ref: Schema.Struct<{
+  /** Defaults to the mount's cwd. Set it to work in a subdirectory of the mount. */
+  readonly directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
+}>;
+type Ref = typeof Ref.Type;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+  /** The absolute cwd tools run in; `space.location` is the root it lives under. */
+  readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+  readonly space: typeof Info$2;
+  readonly project: typeof Info$1;
+}>, {}>;
+declare class Info extends Info_base {}
+interface Interface extends Info {}
+declare const Service_base: Context.ServiceClass<Service, "@codeworksh/plugin/location/Service", Interface>;
+declare class Service extends Service_base {}
+declare const DirectoryNotFoundError_base: Schema.Class<DirectoryNotFoundError, Schema.TaggedStruct<"Location.DirectoryNotFoundError", {
+  directory: Schema.brand<Schema.String, "AbsolutePath">;
+  sandboxInstanceId: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+}>, import("effect/Cause").YieldableError>;
+declare class DirectoryNotFoundError extends DirectoryNotFoundError_base {}
+declare const NotDirectoryError_base: Schema.Class<NotDirectoryError, Schema.TaggedStruct<"Location.NotDirectoryError", {
+  directory: Schema.brand<Schema.String, "AbsolutePath">;
+  sandboxInstanceId: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+}>, import("effect/Cause").YieldableError>;
+declare class NotDirectoryError extends NotDirectoryError_base {}
+type Error = DirectoryNotFoundError | NotDirectoryError;
+//#endregion
+export { NotDirectoryError as a, Interface as i, Error as n, Ref as o, Info as r, Service as s, DirectoryNotFoundError as t };
+//# sourceMappingURL=location-D4hAfuXF.d.mts.map

package/location.d.mts

@@ -0,0 +1,2 @@
+import { a as NotDirectoryError, i as Interface, n as Error, o as Ref, r as Info, s as Service, t as DirectoryNotFoundError } from "./location-D4hAfuXF.mjs";
+export { DirectoryNotFoundError, Error, Info, Interface, NotDirectoryError, Ref, Service };

package/location.mjs

@@ -0,0 +1,48 @@
+import { AbsolutePath } from "./schema.mjs";
+import { Info as Info$1 } from "./project.mjs";
+import { ID } from "./sandbox/instance.mjs";
+import { Info as Info$2 } from "./space.mjs";
+import { Context, Schema } from "effect";
+//#region src/location.ts
+/**
+* Where work happens: a directory inside a space.
+*
+* The pair (space, directory) is the key. A path alone does not name a place —
+* `/app/repo` on the host and `/app/repo` inside a remote sandbox are different
+* trees wearing the same spelling — so the space carries the env and the
+* root it lives under (`space.location`), and `directory` is the absolute cwd
+* equal to or beneath that root. Sessions sharing a space share the project;
+* worktree relationships stay a Project concern beneath it.
+*
+* **Both halves come from the mount, so `Ref` is overrides and nothing else.**
+* A Location is a directory *within* a mounted namespace — the mount has to be
+* resolved first, the way a volume is mounted before any path on it means
+* anything — and once it is, the namespace and the working directory are already
+* in scope. Re-declaring them would be two spellings of one value, free to drift;
+* a Location pointing somewhere its own shell is not becomes unrepresentable
+* rather than merely avoided by discipline.
+*
+* Only the shape and the service tag live here. Building one needs Project, Space, Repo and Git,
+* which belong to the harness; a plugin receives a resolved `Info` on its context and asks for
+* {@link Service} when it needs the live one.
+*/
+const Ref = Schema.Struct({ 
+/** Defaults to the mount's cwd. Set it to work in a subdirectory of the mount. */
+directory: Schema.optional(AbsolutePath) }).annotate({ identifier: "Location.Ref" });
+var Info = class extends Schema.Class("Location.Info")({
+	/** The absolute cwd tools run in; `space.location` is the root it lives under. */
+	directory: AbsolutePath,
+	space: Info$2,
+	project: Info$1
+}) {};
+var Service = class extends Context.Service()("@codeworksh/plugin/location/Service") {};
+const Fields = {
+	directory: AbsolutePath,
+	sandboxInstanceId: ID
+};
+var DirectoryNotFoundError = class extends Schema.TaggedError()("Location.DirectoryNotFoundError", Fields) {};
+var NotDirectoryError = class extends Schema.TaggedError()("Location.NotDirectoryError", Fields) {};
+//#endregion
+export { DirectoryNotFoundError, Info, NotDirectoryError, Ref, Service };
+
+//# sourceMappingURL=location.mjs.map

package/location.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.mjs","names":["SpaceSchema.Info","ProjectSchema.Info","SandboxInstance.ID"],"sources":["../../src/location.ts"],"sourcesContent":["import { Context, Schema } from \"effect\";\nimport { ProjectSchema } from \"./project.ts\";\nimport { AbsolutePath } from \"./schema.ts\";\nimport { SandboxInstance } from \"./sandbox/instance.ts\";\nimport { SpaceSchema } from \"./space.ts\";\n\n/**\n * Where work happens: a directory inside a space.\n *\n * The pair (space, directory) is the key. A path alone does not name a place —\n * `/app/repo` on the host and `/app/repo` inside a remote sandbox are different\n * trees wearing the same spelling — so the space carries the env and the\n * root it lives under (`space.location`), and `directory` is the absolute cwd\n * equal to or beneath that root. Sessions sharing a space share the project;\n * worktree relationships stay a Project concern beneath it.\n *\n * **Both halves come from the mount, so `Ref` is overrides and nothing else.**\n * A Location is a directory *within* a mounted namespace — the mount has to be\n * resolved first, the way a volume is mounted before any path on it means\n * anything — and once it is, the namespace and the working directory are already\n * in scope. Re-declaring them would be two spellings of one value, free to drift;\n * a Location pointing somewhere its own shell is not becomes unrepresentable\n * rather than merely avoided by discipline.\n *\n * Only the shape and the service tag live here. Building one needs Project, Space, Repo and Git,\n * which belong to the harness; a plugin receives a resolved `Info` on its context and asks for\n * {@link Service} when it needs the live one.\n */\nexport const Ref = Schema.Struct({\n\t/** Defaults to the mount's cwd. Set it to work in a subdirectory of the mount. */\n\tdirectory: Schema.optional(AbsolutePath),\n}).annotate({ identifier: \"Location.Ref\" });\nexport type Ref = typeof Ref.Type;\n\nexport class Info extends Schema.Class<Info>(\"Location.Info\")({\n\t/** The absolute cwd tools run in; `space.location` is the root it lives under. */\n\tdirectory: AbsolutePath,\n\tspace: SpaceSchema.Info,\n\tproject: ProjectSchema.Info,\n}) {}\n\nexport interface Interface extends Info {}\n\nexport class Service extends Context.Service<Service, Interface>()(\"@codeworksh/plugin/location/Service\") {}\n\nconst Fields = {\n\tdirectory: AbsolutePath,\n\tsandboxInstanceId: SandboxInstance.ID,\n};\n\nexport class DirectoryNotFoundError extends Schema.TaggedError<DirectoryNotFoundError>()(\n\t\"Location.DirectoryNotFoundError\",\n\tFields,\n) {}\n\nexport class NotDirectoryError extends Schema.TaggedError<NotDirectoryError>()(\"Location.NotDirectoryError\", Fields) {}\n\nexport type Error = DirectoryNotFoundError | NotDirectoryError;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,MAAM,OAAO,OAAO;;AAEhC,WAAW,OAAO,SAAS,YAAY,EACxC,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,eAAe,CAAC;AAG1C,IAAa,OAAb,cAA0B,OAAO,MAAY,eAAe,CAAC,CAAC;;CAE7D,WAAW;CACX,OAAOA;CACP,SAASC;AACV,CAAC,CAAC,CAAC,CAAC;AAIJ,IAAa,UAAb,cAA6B,QAAQ,QAA4B,CAAC,CAAC,qCAAqC,CAAC,CAAC,CAAC;AAE3G,MAAM,SAAS;CACd,WAAW;CACX,mBAAmBC;AACpB;AAEA,IAAa,yBAAb,cAA4C,OAAO,YAAoC,CAAC,CACvF,mCACA,MACD,CAAC,CAAC,CAAC;AAEH,IAAa,oBAAb,cAAuC,OAAO,YAA+B,CAAC,CAAC,8BAA8B,MAAM,CAAC,CAAC,CAAC"}