effect-cf 0.28.1 → 0.30.0

package/dist/{DurableObjectState-OupNMMUl.d.mts → DurableObjectState-D3k-WRnd.d.mts}

@@ -1,5 +1,5 @@
 import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
-import { Cause, Context, Effect, Layer, Option, Predicate, Schema, Scope } from "effect";
+import { Cause, Context, Duration, Effect, Layer, Option, Predicate, Schema, Scope } from "effect";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
 declare namespace DurableObjectStorage_d_exports {
@@ -84,6 +84,8 @@ interface DurableObjectTransaction {
   rollback(): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
   setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  /** Schedules the alarm after a delay measured by the Effect clock. */
+  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
 }
 /**
@@ -110,6 +112,8 @@ interface DurableObjectStorage {
   deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
   setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
+  /** Schedules the alarm after a delay measured by the Effect clock. */
+  setAlarmAfter(delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   /**
    * SQLite-backed Durable Object storage only.

package/dist/Sandbox.d.mts

@@ -0,0 +1,222 @@
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
+import { n as ContainerStartOptions, r as ContainerStopSignal } from "./ContainerNamespace-CFjiLw8b.mjs";
+import { Context, Effect, Layer, Option, Stream } from "effect";
+import { BackupOptions, BackupOptions as BackupOptions$1, CheckChangesOptions, CheckChangesOptions as CheckChangesOptions$1, CheckChangesResult, CheckChangesResult as CheckChangesResult$1, CreateTerminalOptions, CreateTerminalOptions as CreateTerminalOptions$1, DirectoryBackup, DirectoryBackup as DirectoryBackup$1, ExecOptions, ExecOptions as ExecOptions$1, FileWatchSSEEvent, FileWatchSSEEvent as FileWatchSSEEvent$1, ISandbox, ISandbox as ISandbox$1, ListFilesOptions, ListFilesOptions as ListFilesOptions$1, MountBucketOptions, MountBucketOptions as MountBucketOptions$1, ProcessExit, ProcessExit as ProcessExit$1, ProcessLogEvent, ProcessLogEvent as ProcessLogEvent$1, ProcessLogsOptions, ProcessLogsOptions as ProcessLogsOptions$1, ProcessOutput, ProcessOutput as ProcessOutput$1, ProcessOutputOptions, ProcessOutputOptions as ProcessOutputOptions$1, ProcessStatus, ProcessStatus as ProcessStatus$1, RestoreBackupResult, RestoreBackupResult as RestoreBackupResult$1, SandboxCommand, SandboxCommand as SandboxCommand$1, SandboxOptions, SandboxOptions as SandboxOptions$1, SandboxProcess, SandboxProcess as SandboxProcess$1, Terminal, Terminal as Terminal$1, TerminalOutputCursor, TerminalOutputCursor as TerminalOutputCursor$1, TerminalOutputEvent, TerminalOutputEvent as TerminalOutputEvent$1, TerminalOutputOptions, TerminalOutputOptions as TerminalOutputOptions$1, TerminalSnapshot, TerminalSnapshot as TerminalSnapshot$1, TunnelInfo, TunnelInfo as TunnelInfo$1, TunnelOptions, TunnelOptions as TunnelOptions$1, WaitForExitOptions, WaitForExitOptions as WaitForExitOptions$1, WaitForLogOptions, WaitForLogOptions as WaitForLogOptions$1, WaitForLogResult, WaitForLogResult as WaitForLogResult$1, WaitForPortOptions, WaitForPortOptions as WaitForPortOptions$1, WatchOptions, WatchOptions as WatchOptions$1 } from "@cloudflare/sandbox";
+//#region src/Sandbox.d.ts
+/** Sandbox namespace binding metadata. */
+interface SandboxDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+declare const SandboxOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SandboxOperationError";
+} & Readonly<A>;
+/** Failure raised when invoking a sandbox operation. */
+declare class SandboxOperationError extends SandboxOperationError_base<{
+  readonly binding: string;
+  readonly instance: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+/**
+ * Structural Durable Object namespace shape required by `getSandbox()`.
+ *
+ * This is structural so importing this module does not require
+ * `@cloudflare/sandbox` at runtime; the package is loaded lazily when a
+ * sandbox instance is first requested.
+ */
+interface SandboxNamespaceResource {
+  idFromName(name: string): globalThis.DurableObjectId;
+  get(id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): globalThis.DurableObjectStub;
+}
+/** Result of `writeFile` as reported by the sandbox client. */
+type WriteFileResult = Awaited<ReturnType<ISandbox$1["writeFile"]>>;
+/** Result of `readFile` as reported by the sandbox client. */
+type ReadFileResult = Awaited<ReturnType<ISandbox$1["readFile"]>>;
+/** Result of `mkdir` as reported by the sandbox client. */
+type MkdirResult = Awaited<ReturnType<ISandbox$1["mkdir"]>>;
+/** Result of `deleteFile` as reported by the sandbox client. */
+type DeleteFileResult = Awaited<ReturnType<ISandbox$1["deleteFile"]>>;
+/** Result of `renameFile` as reported by the sandbox client. */
+type RenameFileResult = Awaited<ReturnType<ISandbox$1["renameFile"]>>;
+/** Result of `moveFile` as reported by the sandbox client. */
+type MoveFileResult = Awaited<ReturnType<ISandbox$1["moveFile"]>>;
+/** Result of `listFiles` as reported by the sandbox client. */
+type ListFilesResult = Awaited<ReturnType<ISandbox$1["listFiles"]>>;
+/** Result of `exists` as reported by the sandbox client. */
+type FileExistsResult = Awaited<ReturnType<ISandbox$1["exists"]>>;
+/** Text encodings accepted by `readFile`. */
+type ReadFileEncoding = "utf-8" | "utf8" | "base64";
+/** Options accepted by `exposePort`. */
+interface ExposePortOptions {
+  readonly name?: string;
+  readonly hostname: string;
+  readonly token?: string;
+}
+/** Preview URL information returned by `exposePort`. */
+interface ExposedPort {
+  readonly url: string;
+  readonly port: number;
+  readonly name?: string;
+}
+/** Currently forwardable preview URL returned by `getExposedPorts`. */
+interface ExposedPortStatus {
+  readonly url: string;
+  readonly port: number;
+  readonly status: "active";
+}
+/** Structural tunnel API surface exposed by a sandbox client. */
+interface SandboxTunnelsResource {
+  get(port: number, options?: TunnelOptions$1): Promise<TunnelInfo$1>;
+  list(): Promise<Array<TunnelInfo$1>>;
+  destroy(portOrInfo: number | TunnelInfo$1): Promise<void>;
+}
+/**
+ * Structural surface of the client returned by `getSandbox()` that this
+ * module wraps: the `ISandbox` RPC contract plus the lifecycle, port, and
+ * tunnel methods the client proxy forwards to the Sandbox Durable Object.
+ */
+interface SandboxClientResource extends ISandbox$1 {
+  start(options?: ContainerStartOptions): Promise<void>;
+  stop(signal?: ContainerStopSignal): Promise<void>;
+  destroy(): Promise<void>;
+  containerFetch(requestOrUrl: Request | string | URL, port?: number): Promise<Response>;
+  exposePort(port: number, options: ExposePortOptions): Promise<ExposedPort>;
+  unexposePort(port: number): Promise<void>;
+  getExposedPorts(hostname: string): Promise<Array<ExposedPortStatus>>;
+  isPortExposed(port: number): Promise<boolean>;
+  validatePortToken(port: number, token: string): Promise<boolean>;
+  readonly tunnels: SandboxTunnelsResource;
+}
+/** Effect-wrapped handle for one process started inside a sandbox. */
+interface SandboxProcessHandle {
+  readonly id: string;
+  readonly pid: number;
+  readonly rawUnsafe: Effect.Effect<SandboxProcess$1>;
+  readonly status: Effect.Effect<ProcessStatus$1, SandboxOperationError>;
+  readonly exitCode: Effect.Effect<number, SandboxOperationError>;
+  readonly logs: (options?: Omit<ProcessLogsOptions$1, "signal">) => Stream.Stream<ProcessLogEvent$1, SandboxOperationError>;
+  readonly waitForLog: (pattern: string | RegExp, options?: Omit<WaitForLogOptions$1, "signal">) => Effect.Effect<WaitForLogResult$1, SandboxOperationError>;
+  readonly waitForExit: (options?: Omit<WaitForExitOptions$1, "signal">) => Effect.Effect<ProcessExit$1, SandboxOperationError>;
+  readonly output: (options?: Omit<ProcessOutputOptions$1, "signal">) => Effect.Effect<ProcessOutput$1<Uint8Array>, SandboxOperationError>;
+  readonly outputText: (options?: Omit<ProcessOutputOptions$1, "signal">) => Effect.Effect<ProcessOutput$1<string>, SandboxOperationError>;
+  readonly waitForPort: (port: number, options?: Omit<WaitForPortOptions$1, "signal">) => Effect.Effect<void, SandboxOperationError>;
+  readonly kill: (signal?: number) => Effect.Effect<void, SandboxOperationError>;
+}
+/** Effect-wrapped handle for one interactive terminal inside a sandbox. */
+interface SandboxTerminalHandle {
+  readonly id: string;
+  readonly rawUnsafe: Effect.Effect<Terminal$1>;
+  readonly snapshot: Effect.Effect<TerminalSnapshot$1, SandboxOperationError>;
+  readonly write: (data: Uint8Array) => Effect.Effect<void, SandboxOperationError>;
+  readonly resize: (cols: number, rows: number) => Effect.Effect<void, SandboxOperationError>;
+  readonly output: (options?: Omit<TerminalOutputOptions$1, "signal">) => Stream.Stream<TerminalOutputEvent$1, SandboxOperationError>;
+  readonly waitForExit: (options?: Omit<WaitForExitOptions$1, "signal">) => Effect.Effect<ProcessExit$1, SandboxOperationError>;
+  readonly interrupt: Effect.Effect<void, SandboxOperationError>;
+  readonly terminate: Effect.Effect<void, SandboxOperationError>;
+  readonly connect: (request: Request, options?: {
+    readonly cursor?: TerminalOutputCursor$1;
+    readonly cols?: number;
+    readonly rows?: number;
+  }) => Effect.Effect<Response, SandboxOperationError>;
+}
+/** Effect-wrapped tunnel operations for one sandbox instance. */
+interface SandboxTunnelsClient {
+  readonly get: (port: number, options?: TunnelOptions$1) => Effect.Effect<TunnelInfo$1, SandboxOperationError>;
+  readonly list: Effect.Effect<Array<TunnelInfo$1>, SandboxOperationError>;
+  readonly destroy: (portOrInfo: number | TunnelInfo$1) => Effect.Effect<void, SandboxOperationError>;
+}
+/** Effect-wrapped client for one named sandbox instance. */
+interface SandboxInstanceClient {
+  readonly rawUnsafe: Effect.Effect<SandboxClientResource>;
+  readonly exec: (command: SandboxCommand$1, options?: ExecOptions$1) => Effect.Effect<SandboxProcessHandle, SandboxOperationError>;
+  readonly getProcess: (id: string) => Effect.Effect<Option.Option<SandboxProcessHandle>, SandboxOperationError>;
+  readonly listProcesses: Effect.Effect<Array<ProcessStatus$1>, SandboxOperationError>;
+  readonly writeFile: (path: string, content: string | ReadableStream<Uint8Array>, options?: {
+    readonly encoding?: string;
+  }) => Effect.Effect<WriteFileResult, SandboxOperationError>;
+  readonly readFile: (path: string, options?: {
+    readonly encoding?: ReadFileEncoding;
+  }) => Effect.Effect<ReadFileResult, SandboxOperationError>;
+  readonly readFileStream: (path: string) => Stream.Stream<Uint8Array, SandboxOperationError>;
+  readonly mkdir: (path: string, options?: {
+    readonly recursive?: boolean;
+  }) => Effect.Effect<MkdirResult, SandboxOperationError>;
+  readonly deleteFile: (path: string) => Effect.Effect<DeleteFileResult, SandboxOperationError>;
+  readonly renameFile: (oldPath: string, newPath: string) => Effect.Effect<RenameFileResult, SandboxOperationError>;
+  readonly moveFile: (sourcePath: string, destinationPath: string) => Effect.Effect<MoveFileResult, SandboxOperationError>;
+  readonly listFiles: (path: string, options?: ListFilesOptions$1) => Effect.Effect<ListFilesResult, SandboxOperationError>;
+  readonly exists: (path: string) => Effect.Effect<FileExistsResult, SandboxOperationError>;
+  readonly watch: (path: string, options?: WatchOptions$1) => Stream.Stream<FileWatchSSEEvent$1, SandboxOperationError>;
+  readonly checkChanges: (path: string, options?: CheckChangesOptions$1) => Effect.Effect<CheckChangesResult$1, SandboxOperationError>;
+  readonly setEnvVars: (envVars: Record<string, string | undefined>) => Effect.Effect<void, SandboxOperationError>;
+  readonly exposePort: (port: number, options: ExposePortOptions) => Effect.Effect<ExposedPort, SandboxOperationError>;
+  readonly unexposePort: (port: number) => Effect.Effect<void, SandboxOperationError>;
+  readonly getExposedPorts: (hostname: string) => Effect.Effect<Array<ExposedPortStatus>, SandboxOperationError>;
+  readonly isPortExposed: (port: number) => Effect.Effect<boolean, SandboxOperationError>;
+  readonly validatePortToken: (port: number, token: string) => Effect.Effect<boolean, SandboxOperationError>;
+  readonly containerFetch: (requestOrUrl: Request | string | URL, port?: number) => Effect.Effect<Response, SandboxOperationError>;
+  readonly wsConnect: (request: Request, port: number) => Effect.Effect<Response, SandboxOperationError>;
+  readonly mountBucket: (bucket: string, mountPath: string, options: MountBucketOptions$1) => Effect.Effect<void, SandboxOperationError>;
+  readonly unmountBucket: (mountPath: string) => Effect.Effect<void, SandboxOperationError>;
+  readonly createBackup: (options: BackupOptions$1) => Effect.Effect<DirectoryBackup$1, SandboxOperationError>;
+  readonly restoreBackup: (backup: DirectoryBackup$1) => Effect.Effect<RestoreBackupResult$1, SandboxOperationError>;
+  readonly createTerminal: (options: CreateTerminalOptions$1) => Effect.Effect<SandboxTerminalHandle, SandboxOperationError>;
+  readonly getTerminal: (id: string) => Effect.Effect<Option.Option<SandboxTerminalHandle>, SandboxOperationError>;
+  readonly listTerminals: Effect.Effect<Array<SandboxTerminalHandle>, SandboxOperationError>;
+  readonly tunnels: SandboxTunnelsClient;
+  readonly start: (options?: ContainerStartOptions) => Effect.Effect<void, SandboxOperationError>;
+  readonly stop: (signal?: ContainerStopSignal) => Effect.Effect<void, SandboxOperationError>;
+  readonly destroy: Effect.Effect<void, SandboxOperationError>;
+}
+/** Effect client for a Sandbox Durable Object namespace binding. */
+interface SandboxNamespaceClient<Namespace extends SandboxNamespaceResource = SandboxNamespaceResource> {
+  readonly definition: SandboxDefinition;
+  readonly get: (name: string, options?: SandboxOptions$1) => Effect.Effect<SandboxInstanceClient, SandboxOperationError>;
+  readonly rawUnsafe: Effect.Effect<Namespace>;
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string, Namespace extends SandboxNamespaceResource = SandboxNamespaceResource> extends Context.ServiceClass<Self, `effect-cf/Sandbox/${Id}`, SandboxNamespaceClient<Namespace>> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+  readonly get: (name: string, options?: SandboxOptions$1) => Effect.Effect<SandboxInstanceClient, SandboxOperationError, Self>;
+  readonly rawUnsafe: Effect.Effect<Namespace, never, Self>;
+}
+/**
+ * Wraps an already-created sandbox client (the value returned by
+ * `getSandbox()` from `@cloudflare/sandbox`) into an Effect client.
+ *
+ * Prefer {@link Tag}/{@link make} with a layer for application code; this
+ * entry point exists for advanced composition and testing.
+ */
+declare const fromSandboxClient: (client: SandboxClientResource, definition: SandboxDefinition, instance: string) => SandboxInstanceClient;
+declare const isSandboxNamespaceResource: <Candidate>(value: Candidate) => value is Candidate & SandboxNamespaceResource;
+declare const makeClient: (definition: SandboxDefinition) => <Namespace extends SandboxNamespaceResource>(namespace: Namespace) => SandboxNamespaceClient<Namespace>;
+declare const layer: <Self, Namespace extends SandboxNamespaceResource>(tag: Context.Service<Self, SandboxNamespaceClient<Namespace>>, definition: SandboxDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<SandboxNamespaceService<Id>, Id, SandboxNamespaceResource>;
+declare const SandboxNamespaceServiceTypeId: unique symbol;
+/** Nominal service marker for Sandbox namespaces created with {@link make}. */
+interface SandboxNamespaceService<Id extends string> {
+  readonly [SandboxNamespaceServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+/** Creates a typed Effect service for a Cloudflare Sandbox namespace. */
+declare const Tag: <Self, Namespace extends SandboxNamespaceResource = SandboxNamespaceResource>() => <Id extends string>(id: Id) => TagClass<Self, Id, Namespace>;
+declare const Sandbox: typeof Tag;
+/**
+ * Routes sandbox preview-URL requests (`https://<port>-<sandbox-id>-<token>.<host>`)
+ * to the owning sandbox, mirroring `proxyToSandbox` from `@cloudflare/sandbox`.
+ *
+ * Call this before any other routing in a Worker `fetch` handler; it resolves
+ * to `Option.none()` for requests that are not preview-URL traffic.
+ */
+declare const proxyToSandbox: (request: Request<unknown, CfProperties<unknown>>, options?: {
+  readonly binding?: string;
+} | undefined) => Effect.Effect<Option.Option<Response>, SandboxOperationError, WorkerEnvironment>;
+//#endregion
+export { type BackupOptions, type CheckChangesOptions, type CheckChangesResult, type CreateTerminalOptions, DeleteFileResult, type DirectoryBackup, type ExecOptions, ExposePortOptions, ExposedPort, ExposedPortStatus, FileExistsResult, type FileWatchSSEEvent, type ISandbox, LayerOptions, type ListFilesOptions, ListFilesResult, MkdirResult, type MountBucketOptions, MoveFileResult, type ProcessExit, type ProcessLogEvent, type ProcessLogsOptions, type ProcessOutput, type ProcessOutputOptions, type ProcessStatus, ReadFileEncoding, ReadFileResult, RenameFileResult, type RestoreBackupResult, Sandbox, SandboxClientResource, type SandboxCommand, SandboxDefinition, SandboxInstanceClient, SandboxNamespaceClient, SandboxNamespaceResource, SandboxNamespaceService, SandboxOperationError, type SandboxOptions, type SandboxProcess, SandboxProcessHandle, SandboxTerminalHandle, SandboxTunnelsClient, SandboxTunnelsResource, Tag, TagClass, type Terminal, type TerminalOutputCursor, type TerminalOutputEvent, type TerminalOutputOptions, type TerminalSnapshot, type TunnelInfo, type TunnelOptions, type WaitForExitOptions, type WaitForLogOptions, type WaitForLogResult, type WaitForPortOptions, type WatchOptions, WriteFileResult, fromSandboxClient, isSandboxNamespaceResource, layer, make, makeClient, proxyToSandbox };

package/dist/Sandbox.mjs

@@ -0,0 +1,361 @@
+import { a as WorkerEnvironment, t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
+import { r as layer$1 } from "./Binding-pfilNJmP.mjs";
+import { Context, Data, Effect, Option, Predicate, Stream } from "effect";
+//#region src/Sandbox.ts
+const expectedSandboxNamespace = "Sandbox Durable Object namespace binding with idFromName() and get()";
+/** Failure raised when invoking a sandbox operation. */
+var SandboxOperationError = class extends Data.TaggedError("SandboxOperationError") {
+	get message() {
+		return `Sandbox ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
+	}
+};
+const trySandboxPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => new SandboxOperationError({
+		binding: definition.binding,
+		instance,
+		operation,
+		cause
+	})
+});
+const sandboxStream = (definition, instance, operation, acquire) => Stream.unwrap(Effect.map(trySandboxPromise(definition, instance, operation, acquire), (readable) => Stream.fromReadableStream({
+	evaluate: () => readable,
+	onError: (cause) => new SandboxOperationError({
+		binding: definition.binding,
+		instance,
+		operation,
+		cause
+	})
+})));
+const decodeSseData = (payload) => {
+	if (payload === "[DONE]" || payload.trim() === "") return [];
+	try {
+		return [JSON.parse(payload)];
+	} catch {
+		return [];
+	}
+};
+/**
+* Decodes the sandbox runtime's `data:`-framed Server-Sent Events byte stream
+* into JSON event values, mirroring `parseSSEStream` from
+* `@cloudflare/sandbox` without requiring the package at runtime.
+*/
+const decodeSseEvents = (bytes) => bytes.pipe(Stream.decodeText(), Stream.splitLines, Stream.mapAccum(() => [], (pending, line) => {
+	if (line === "") return pending.length > 0 ? [[], decodeSseData(pending.join("\n"))] : [pending, []];
+	if (line.startsWith("data:")) {
+		const value = line.startsWith("data: ") ? line.slice(6) : line.slice(5);
+		return [[...pending, value], []];
+	}
+	return [pending, []];
+}, { onHalt: (pending) => pending.length > 0 ? decodeSseData(pending.join("\n")) : [] }));
+const makeProcessHandle = (definition, instance, process) => {
+	const spanOptions = (operation) => ({ attributes: {
+		binding: definition.binding,
+		instance,
+		processId: process.id,
+		operation
+	} });
+	return {
+		id: process.id,
+		pid: process.pid,
+		rawUnsafe: Effect.succeed(process),
+		status: trySandboxPromise(definition, instance, "process.status", () => process.status()).pipe(Effect.withSpan("Sandbox.process.status", spanOptions("process.status"))),
+		exitCode: trySandboxPromise(definition, instance, "process.exitCode", () => process.exitCode).pipe(Effect.withSpan("Sandbox.process.exitCode", spanOptions("process.exitCode"))),
+		logs: (options) => sandboxStream(definition, instance, "process.logs", (signal) => process.logs({
+			...options,
+			signal
+		})),
+		waitForLog: Effect.fn("Sandbox.process.waitForLog", spanOptions("process.waitForLog"))(function* (pattern, options) {
+			return yield* trySandboxPromise(definition, instance, "process.waitForLog", (signal) => process.waitForLog(pattern, {
+				...options,
+				signal
+			}));
+		}),
+		waitForExit: Effect.fn("Sandbox.process.waitForExit", spanOptions("process.waitForExit"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "process.waitForExit", (signal) => process.waitForExit({
+				...options,
+				signal
+			}));
+		}),
+		output: Effect.fn("Sandbox.process.output", spanOptions("process.output"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "process.output", (signal) => process.output({
+				...options,
+				signal
+			}));
+		}),
+		outputText: Effect.fn("Sandbox.process.outputText", spanOptions("process.outputText"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "process.outputText", (signal) => process.output({
+				...options,
+				encoding: "utf8",
+				signal
+			}));
+		}),
+		waitForPort: Effect.fn("Sandbox.process.waitForPort", spanOptions("process.waitForPort"))(function* (port, options) {
+			return yield* trySandboxPromise(definition, instance, "process.waitForPort", (signal) => process.waitForPort(port, {
+				...options,
+				signal
+			}));
+		}),
+		kill: Effect.fn("Sandbox.process.kill", spanOptions("process.kill"))(function* (signal) {
+			return yield* trySandboxPromise(definition, instance, "process.kill", () => process.kill(signal));
+		})
+	};
+};
+const makeTerminalHandle = (definition, instance, terminal) => {
+	const spanOptions = (operation) => ({ attributes: {
+		binding: definition.binding,
+		instance,
+		terminalId: terminal.id,
+		operation
+	} });
+	return {
+		id: terminal.id,
+		rawUnsafe: Effect.succeed(terminal),
+		snapshot: trySandboxPromise(definition, instance, "terminal.snapshot", () => terminal.getSnapshot()).pipe(Effect.withSpan("Sandbox.terminal.snapshot", spanOptions("terminal.snapshot"))),
+		write: Effect.fn("Sandbox.terminal.write", spanOptions("terminal.write"))(function* (data) {
+			return yield* trySandboxPromise(definition, instance, "terminal.write", () => terminal.write(data));
+		}),
+		resize: Effect.fn("Sandbox.terminal.resize", spanOptions("terminal.resize"))(function* (cols, rows) {
+			return yield* trySandboxPromise(definition, instance, "terminal.resize", () => terminal.resize(cols, rows));
+		}),
+		output: (options) => sandboxStream(definition, instance, "terminal.output", (signal) => terminal.output({
+			...options,
+			signal
+		})),
+		waitForExit: Effect.fn("Sandbox.terminal.waitForExit", spanOptions("terminal.waitForExit"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "terminal.waitForExit", (signal) => terminal.waitForExit({
+				...options,
+				signal
+			}));
+		}),
+		interrupt: trySandboxPromise(definition, instance, "terminal.interrupt", () => terminal.interrupt()).pipe(Effect.withSpan("Sandbox.terminal.interrupt", spanOptions("terminal.interrupt"))),
+		terminate: trySandboxPromise(definition, instance, "terminal.terminate", () => terminal.terminate()).pipe(Effect.withSpan("Sandbox.terminal.terminate", spanOptions("terminal.terminate"))),
+		connect: Effect.fn("Sandbox.terminal.connect", spanOptions("terminal.connect"))(function* (request, options) {
+			return yield* trySandboxPromise(definition, instance, "terminal.connect", () => terminal.connect(request, options));
+		})
+	};
+};
+/**
+* Wraps an already-created sandbox client (the value returned by
+* `getSandbox()` from `@cloudflare/sandbox`) into an Effect client.
+*
+* Prefer {@link Tag}/{@link make} with a layer for application code; this
+* entry point exists for advanced composition and testing.
+*/
+const fromSandboxClient = (client, definition, instance) => {
+	const spanOptions = (operation) => ({ attributes: {
+		binding: definition.binding,
+		instance,
+		operation
+	} });
+	return {
+		rawUnsafe: Effect.succeed(client),
+		exec: Effect.fn("Sandbox.exec", spanOptions("exec"))(function* (command, options) {
+			const process = yield* trySandboxPromise(definition, instance, "exec", () => client.exec(command, options));
+			return makeProcessHandle(definition, instance, process);
+		}),
+		getProcess: Effect.fn("Sandbox.getProcess", spanOptions("getProcess"))(function* (id) {
+			const process = yield* trySandboxPromise(definition, instance, "getProcess", () => client.getProcess(id));
+			return Option.map(Option.fromNullishOr(process), (found) => makeProcessHandle(definition, instance, found));
+		}),
+		listProcesses: trySandboxPromise(definition, instance, "listProcesses", () => client.listProcesses()).pipe(Effect.withSpan("Sandbox.listProcesses", spanOptions("listProcesses"))),
+		writeFile: Effect.fn("Sandbox.writeFile", spanOptions("writeFile"))(function* (path, content, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "writeFile", () => client.writeFile(path, content, options));
+		}),
+		readFile: Effect.fn("Sandbox.readFile", spanOptions("readFile"))(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "readFile", () => client.readFile(path, options));
+		}),
+		readFileStream: (path) => sandboxStream(definition, instance, "readFileStream", () => client.readFileStream(path)),
+		mkdir: Effect.fn("Sandbox.mkdir", spanOptions("mkdir"))(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "mkdir", () => client.mkdir(path, options));
+		}),
+		deleteFile: Effect.fn("Sandbox.deleteFile", spanOptions("deleteFile"))(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "deleteFile", () => client.deleteFile(path));
+		}),
+		renameFile: Effect.fn("Sandbox.renameFile", spanOptions("renameFile"))(function* (oldPath, newPath) {
+			yield* Effect.annotateCurrentSpan({
+				oldPath,
+				newPath
+			});
+			return yield* trySandboxPromise(definition, instance, "renameFile", () => client.renameFile(oldPath, newPath));
+		}),
+		moveFile: Effect.fn("Sandbox.moveFile", spanOptions("moveFile"))(function* (sourcePath, destinationPath) {
+			yield* Effect.annotateCurrentSpan({
+				sourcePath,
+				destinationPath
+			});
+			return yield* trySandboxPromise(definition, instance, "moveFile", () => client.moveFile(sourcePath, destinationPath));
+		}),
+		listFiles: Effect.fn("Sandbox.listFiles", spanOptions("listFiles"))(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "listFiles", () => client.listFiles(path, options));
+		}),
+		exists: Effect.fn("Sandbox.exists", spanOptions("exists"))(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "exists", () => client.exists(path));
+		}),
+		watch: (path, options) => decodeSseEvents(sandboxStream(definition, instance, "watch", () => client.watch(path, options))),
+		checkChanges: Effect.fn("Sandbox.checkChanges", spanOptions("checkChanges"))(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* trySandboxPromise(definition, instance, "checkChanges", () => client.checkChanges(path, options));
+		}),
+		setEnvVars: Effect.fn("Sandbox.setEnvVars", spanOptions("setEnvVars"))(function* (envVars) {
+			return yield* trySandboxPromise(definition, instance, "setEnvVars", () => client.setEnvVars(envVars));
+		}),
+		exposePort: Effect.fn("Sandbox.exposePort", spanOptions("exposePort"))(function* (port, options) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "exposePort", () => client.exposePort(port, options));
+		}),
+		unexposePort: Effect.fn("Sandbox.unexposePort", spanOptions("unexposePort"))(function* (port) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "unexposePort", () => client.unexposePort(port));
+		}),
+		getExposedPorts: Effect.fn("Sandbox.getExposedPorts", spanOptions("getExposedPorts"))(function* (hostname) {
+			return yield* trySandboxPromise(definition, instance, "getExposedPorts", () => client.getExposedPorts(hostname));
+		}),
+		isPortExposed: Effect.fn("Sandbox.isPortExposed", spanOptions("isPortExposed"))(function* (port) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "isPortExposed", () => client.isPortExposed(port));
+		}),
+		validatePortToken: Effect.fn("Sandbox.validatePortToken", spanOptions("validatePortToken"))(function* (port, token) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "validatePortToken", () => client.validatePortToken(port, token));
+		}),
+		containerFetch: Effect.fn("Sandbox.containerFetch", spanOptions("containerFetch"))(function* (requestOrUrl, port) {
+			return yield* trySandboxPromise(definition, instance, "containerFetch", () => client.containerFetch(requestOrUrl, port));
+		}),
+		wsConnect: Effect.fn("Sandbox.wsConnect", spanOptions("wsConnect"))(function* (request, port) {
+			yield* Effect.annotateCurrentSpan("port", port);
+			return yield* trySandboxPromise(definition, instance, "wsConnect", () => client.wsConnect(request, port));
+		}),
+		mountBucket: Effect.fn("Sandbox.mountBucket", spanOptions("mountBucket"))(function* (bucket, mountPath, options) {
+			yield* Effect.annotateCurrentSpan({
+				bucket,
+				mountPath
+			});
+			return yield* trySandboxPromise(definition, instance, "mountBucket", () => client.mountBucket(bucket, mountPath, options));
+		}),
+		unmountBucket: Effect.fn("Sandbox.unmountBucket", spanOptions("unmountBucket"))(function* (mountPath) {
+			yield* Effect.annotateCurrentSpan("mountPath", mountPath);
+			return yield* trySandboxPromise(definition, instance, "unmountBucket", () => client.unmountBucket(mountPath));
+		}),
+		createBackup: Effect.fn("Sandbox.createBackup", spanOptions("createBackup"))(function* (options) {
+			yield* Effect.annotateCurrentSpan("dir", options.dir);
+			return yield* trySandboxPromise(definition, instance, "createBackup", () => client.createBackup(options));
+		}),
+		restoreBackup: Effect.fn("Sandbox.restoreBackup", spanOptions("restoreBackup"))(function* (backup) {
+			yield* Effect.annotateCurrentSpan({
+				backupId: backup.id,
+				dir: backup.dir
+			});
+			return yield* trySandboxPromise(definition, instance, "restoreBackup", () => client.restoreBackup(backup));
+		}),
+		createTerminal: Effect.fn("Sandbox.createTerminal", spanOptions("createTerminal"))(function* (options) {
+			const terminal = yield* trySandboxPromise(definition, instance, "createTerminal", () => client.createTerminal(options));
+			return makeTerminalHandle(definition, instance, terminal);
+		}),
+		getTerminal: Effect.fn("Sandbox.getTerminal", spanOptions("getTerminal"))(function* (id) {
+			const terminal = yield* trySandboxPromise(definition, instance, "getTerminal", () => client.getTerminal(id));
+			return Option.map(Option.fromNullishOr(terminal), (found) => makeTerminalHandle(definition, instance, found));
+		}),
+		listTerminals: trySandboxPromise(definition, instance, "listTerminals", () => client.listTerminals()).pipe(Effect.map((terminals) => terminals.map((terminal) => makeTerminalHandle(definition, instance, terminal))), Effect.withSpan("Sandbox.listTerminals", spanOptions("listTerminals"))),
+		tunnels: {
+			get: Effect.fn("Sandbox.tunnels.get", spanOptions("tunnels.get"))(function* (port, options) {
+				yield* Effect.annotateCurrentSpan("port", port);
+				return yield* trySandboxPromise(definition, instance, "tunnels.get", () => client.tunnels.get(port, options));
+			}),
+			list: trySandboxPromise(definition, instance, "tunnels.list", () => client.tunnels.list()).pipe(Effect.withSpan("Sandbox.tunnels.list", spanOptions("tunnels.list"))),
+			destroy: Effect.fn("Sandbox.tunnels.destroy", spanOptions("tunnels.destroy"))(function* (portOrInfo) {
+				return yield* trySandboxPromise(definition, instance, "tunnels.destroy", () => client.tunnels.destroy(portOrInfo));
+			})
+		},
+		start: Effect.fn("Sandbox.start", spanOptions("start"))(function* (options) {
+			return yield* trySandboxPromise(definition, instance, "start", () => client.start(options));
+		}),
+		stop: Effect.fn("Sandbox.stop", spanOptions("stop"))(function* (signal) {
+			return yield* trySandboxPromise(definition, instance, "stop", () => client.stop(signal));
+		}),
+		destroy: trySandboxPromise(definition, instance, "destroy", () => client.destroy()).pipe(Effect.withSpan("Sandbox.destroy", spanOptions("destroy")))
+	};
+};
+/**
+* Lazily imports `@cloudflare/sandbox`.
+*
+* The package is an optional peer dependency: loading it on first use keeps
+* this module importable (and the rest of `effect-cf` bundleable) in
+* applications that never touch sandboxes.
+*/
+const importSandboxModule = (definition, instance) => Effect.tryPromise({
+	try: () => import("@cloudflare/sandbox"),
+	catch: (cause) => new SandboxOperationError({
+		binding: definition.binding,
+		instance,
+		operation: "import",
+		cause
+	})
+});
+const isSandboxNamespaceResource = (value) => Predicate.hasProperty(value, "idFromName") && Predicate.isFunction(value.idFromName) && Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get);
+const makeClient = (definition) => (namespace) => {
+	return {
+		definition,
+		get: Effect.fn("Sandbox.get", { attributes: {
+			binding: definition.binding,
+			operation: "get"
+		} })(function* (name, options) {
+			yield* Effect.annotateCurrentSpan("instance", name);
+			const sandboxModule = yield* importSandboxModule(definition, name);
+			const nativeNamespace = namespace;
+			const client = yield* Effect.try({
+				try: () => sandboxModule.getSandbox(nativeNamespace, name, options),
+				catch: (cause) => new SandboxOperationError({
+					binding: definition.binding,
+					instance: name,
+					operation: "get",
+					cause
+				})
+			});
+			return fromSandboxClient(client, definition, name);
+		}),
+		rawUnsafe: Effect.succeed(namespace)
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, (value) => isSandboxNamespaceResource(value), makeClient(definition), { expected: expectedSandboxNamespace });
+const make = (id) => Tag()(id);
+/** Creates a typed Effect service for a Cloudflare Sandbox namespace. */
+const Tag = () => (id) => {
+	const tag = Context.Service()(`effect-cf/Sandbox/${id}`);
+	const makeLayer = (definition) => layer(tag, definition);
+	const get = Effect.fnUntraced(function* (name, options) {
+		return yield* (yield* tag).get(name, options);
+	});
+	const rawUnsafe = Effect.flatMap(tag, (namespace) => namespace.rawUnsafe);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer,
+		get,
+		rawUnsafe
+	});
+};
+const Sandbox = Tag;
+/**
+* Routes sandbox preview-URL requests (`https://<port>-<sandbox-id>-<token>.<host>`)
+* to the owning sandbox, mirroring `proxyToSandbox` from `@cloudflare/sandbox`.
+*
+* Call this before any other routing in a Worker `fetch` handler; it resolves
+* to `Option.none()` for requests that are not preview-URL traffic.
+*/
+const proxyToSandbox = Effect.fn("Sandbox.proxyToSandbox")(function* (request, options) {
+	const binding = options?.binding ?? "Sandbox";
+	const definition = { binding };
+	const env = yield* WorkerEnvironment;
+	const resource = Predicate.hasProperty(env, binding) ? env[binding] : void 0;
+	const sandboxModule = yield* importSandboxModule(definition, "preview");
+	const response = yield* trySandboxPromise(definition, "preview", "proxyToSandbox", () => sandboxModule.proxyToSandbox(request, { Sandbox: resource }));
+	return Option.fromNullishOr(response);
+});
+//#endregion
+export { Sandbox, SandboxOperationError, Tag, fromSandboxClient, isSandboxNamespaceResource, layer, make, makeClient, proxyToSandbox };

package/dist/Vitest.d.mts

@@ -1,6 +1,6 @@
 import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-xJJJPmiD.mjs";
-import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-OupNMMUl.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-DUZtKCVM.mjs";
+import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-D3k-WRnd.mjs";
+import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-CtrmxfdT.mjs";
 import { Effect, Layer, Schema } from "effect";
 import { DurableObject } from "cloudflare:workers";
 import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";

package/dist/Vitest.mjs

@@ -1,5 +1,5 @@
 import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-BM0K-Nik.mjs";
-import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-BjkK2kwH.mjs";
+import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-CepagPkX.mjs";
 import { ConfigProvider, Effect, Exit, Layer } from "effect";
 import { env } from "cloudflare:workers";
 import { abortAllDurableObjects as abortAllDurableObjects$1, adminSecretsStore as adminSecretsStore$1, applyD1Migrations as applyD1Migrations$1, createExecutionContext, createMessageBatch, createPagesEventContext, createScheduledController, evictAllDurableObjects as evictAllDurableObjects$1, evictDurableObject as evictDurableObject$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1, listDurableObjectIds as listDurableObjectIds$1, reset as reset$1, runDurableObjectAlarm as runDurableObjectAlarm$1, runInDurableObject as runInDurableObject$1, waitOnExecutionContext } from "cloudflare:test";

package/dist/{WorkflowBinding-DUZtKCVM.d.mts → WorkflowBinding-CtrmxfdT.d.mts}

@@ -1,5 +1,5 @@
 import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
-import { x as ServiceFreeSchema } from "./DurableObjectState-OupNMMUl.mjs";
+import { x as ServiceFreeSchema } from "./DurableObjectState-D3k-WRnd.mjs";
 import { Context, Effect, Option, Schema } from "effect";
 declare namespace WorkflowBinding_d_exports {
   export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };