effect-cf 0.29.0 → 0.31.0

package/dist/{DurableObjectState-DnnLoHV-.mjs → DurableObjectState-CxS5Y2hf.mjs}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
-import { Cause, Context, Data, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
+import { Cause, Clock, Context, Data, Duration, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
 //#region src/DurableObjectStorage.ts
 var DurableObjectStorage_exports = /* @__PURE__ */ __exportAll({
 	StorageOperationError: () => StorageOperationError,
@@ -24,6 +24,11 @@ const tryStoragePromise = (operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => storageError(operation, cause)
 });
+const setAlarmAfter = Effect.fn("DurableObjectStorage.setAlarmAfter")(function* (operation, setAlarm, delay, options) {
+	const now = yield* Clock.currentTimeMillis;
+	const delayMillis = Math.ceil(Duration.toMillis(delay));
+	yield* tryStoragePromise(operation, () => setAlarm(now + delayMillis, options));
+});
 const fromSqlCursor = (cursor) => ({
 	next: () => tryStorageSync("sql.next", () => cursor.next()),
 	toArray: () => tryStorageSync("sql.toArray", () => cursor.toArray()),
@@ -85,6 +90,7 @@ const fromDurableObjectTransaction = (txn) => ({
 	rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
 	getAlarm: (options) => tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),
 	setAlarm: (scheduledTime, options) => tryStoragePromise("transaction.setAlarm", () => txn.setAlarm(scheduledTime, options)),
+	setAlarmAfter: (delay, options) => setAlarmAfter("transaction.setAlarm", (scheduledTime, options) => txn.setAlarm(scheduledTime, options), delay, options),
 	deleteAlarm: (options) => tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options))
 });
 /**
@@ -97,6 +103,7 @@ const fromDurableObjectStorage = (storage) => ({
 	deleteAll: (options) => tryStoragePromise("deleteAll", () => storage.deleteAll(options)),
 	getAlarm: (options) => tryStoragePromise("getAlarm", () => storage.getAlarm(options)),
 	setAlarm: (scheduledTime, options) => tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
+	setAlarmAfter: (delay, options) => setAlarmAfter("setAlarm", (scheduledTime, options) => storage.setAlarm(scheduledTime, options), delay, options),
 	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
 	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
 		let aborted;
@@ -301,7 +308,8 @@ const fromExecutionContext = (ctx, runPromiseExit = (effect) => Effect.runPromis
 		raw: ctx,
 		waitUntil: (effect, options) => schedule(effect, options, options?.mode ?? "observe"),
 		waitUntilPropagating: (effect, options) => schedule(effect, options, "propagate"),
-		passThroughOnException: Effect.sync(() => ctx.passThroughOnException())
+		passThroughOnException: Effect.sync(() => ctx.passThroughOnException()),
+		abort: (reason) => Effect.sync(() => ctx.abort(reason))
 	};
 };
 //#endregion

package/dist/{DurableObjectState-OupNMMUl.d.mts → DurableObjectState-DVIgf0sA.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.
@@ -830,6 +834,8 @@ interface WorkerContextService {
   waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
   waitUntilPropagating<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: Omit<WorkerContextWaitUntilOptions<E, R2>, "mode">): Effect.Effect<void, never, R | R2>;
   readonly passThroughOnException: Effect.Effect<void>;
+  /** Abort the current stateless Worker invocation (`ExecutionContext.abort`). */
+  abort(reason?: string): Effect.Effect<void>;
 }
 declare const WorkerContext_base: Context.ServiceClass<WorkerContext, "effect-cf/WorkerContext", WorkerContextService>;
 /**

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 };