effect-cf 0.48.0 → 0.50.0

package/dist/Sandbox.mjs

@@ -146,147 +146,146 @@ const makeTerminalHandle = (definition, instance, terminal, target) => {
 		})
 	};
 };
-const fromSandboxClient = (client, definition, instance) => makeSandboxClient(client, definition, instance, client);
-const makeSandboxClient = (client, definition, instance, target) => {
-	const attempt = (operation, evaluate) => trySandboxPromise(definition, instance, operation, evaluate, target);
-	const stream = (operation, acquire) => sandboxStream(definition, instance, operation, acquire, target);
+const fromSandboxClient = (client, definition, instance) => makeSandboxClient(Effect.succeed({
+	client,
+	target: client
+}), definition, instance);
+const makeSandboxClient = (resolve, definition, instance) => {
+	const attempt = (operation, evaluate) => Effect.flatMap(resolve, ({ client, target }) => trySandboxPromise(definition, instance, operation, (signal) => evaluate(client, signal, target), target));
+	const stream = (operation, acquire) => Stream.unwrap(Effect.map(resolve, ({ client, target }) => sandboxStream(definition, instance, operation, (signal) => acquire(client, signal), target)));
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
 		operation
 	} });
 	return {
-		rawUnsafe: Effect.succeed(client),
+		rawUnsafe: Effect.map(resolve, ({ client }) => client),
 		exec: Effect.fn("Sandbox.exec", spanOptions("exec"))(function* (command, options) {
-			const process = yield* attempt("exec", () => client.exec(command, options));
-			return makeProcessHandle(definition, instance, process, target);
+			return yield* attempt("exec", (client, _signal, target) => client.exec(command, options).then((process) => makeProcessHandle(definition, instance, process, target)));
 		}),
 		getProcess: Effect.fn("Sandbox.getProcess", spanOptions("getProcess"))(function* (id) {
-			const process = yield* attempt("getProcess", () => client.getProcess(id));
-			return Option.map(Option.fromNullishOr(process), (found) => makeProcessHandle(definition, instance, found, target));
+			return yield* attempt("getProcess", (client, _signal, target) => client.getProcess(id).then((process) => Option.map(Option.fromNullishOr(process), (found) => makeProcessHandle(definition, instance, found, target))));
 		}),
-		listProcesses: attempt("listProcesses", () => client.listProcesses()).pipe(Effect.withSpan("Sandbox.listProcesses", spanOptions("listProcesses"))),
+		listProcesses: attempt("listProcesses", (client) => 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* attempt("writeFile", () => client.writeFile(path, content, options));
+			return yield* attempt("writeFile", (client) => client.writeFile(path, content, options));
 		}),
 		readFile: Effect.fn("Sandbox.readFile", spanOptions("readFile"))(function* (path, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* attempt("readFile", () => client.readFile(path, options));
+			return yield* attempt("readFile", (client) => client.readFile(path, options));
 		}),
-		readFileStream: (path) => stream("readFileStream", () => client.readFileStream(path)),
+		readFileStream: (path) => stream("readFileStream", (client) => client.readFileStream(path)),
 		mkdir: Effect.fn("Sandbox.mkdir", spanOptions("mkdir"))(function* (path, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* attempt("mkdir", () => client.mkdir(path, options));
+			return yield* attempt("mkdir", (client) => client.mkdir(path, options));
 		}),
 		deleteFile: Effect.fn("Sandbox.deleteFile", spanOptions("deleteFile"))(function* (path) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* attempt("deleteFile", () => client.deleteFile(path));
+			return yield* attempt("deleteFile", (client) => client.deleteFile(path));
 		}),
 		renameFile: Effect.fn("Sandbox.renameFile", spanOptions("renameFile"))(function* (oldPath, newPath) {
 			yield* Effect.annotateCurrentSpan({
 				oldPath,
 				newPath
 			});
-			return yield* attempt("renameFile", () => client.renameFile(oldPath, newPath));
+			return yield* attempt("renameFile", (client) => client.renameFile(oldPath, newPath));
 		}),
 		moveFile: Effect.fn("Sandbox.moveFile", spanOptions("moveFile"))(function* (sourcePath, destinationPath) {
 			yield* Effect.annotateCurrentSpan({
 				sourcePath,
 				destinationPath
 			});
-			return yield* attempt("moveFile", () => client.moveFile(sourcePath, destinationPath));
+			return yield* attempt("moveFile", (client) => client.moveFile(sourcePath, destinationPath));
 		}),
 		listFiles: Effect.fn("Sandbox.listFiles", spanOptions("listFiles"))(function* (path, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* attempt("listFiles", () => client.listFiles(path, options));
+			return yield* attempt("listFiles", (client) => client.listFiles(path, options));
 		}),
 		exists: Effect.fn("Sandbox.exists", spanOptions("exists"))(function* (path) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* attempt("exists", () => client.exists(path));
+			return yield* attempt("exists", (client) => client.exists(path));
 		}),
-		watch: (path, options) => decodeSseEvents(stream("watch", () => client.watch(path, options))),
+		watch: (path, options) => decodeSseEvents(stream("watch", (client) => client.watch(path, options))),
 		checkChanges: Effect.fn("Sandbox.checkChanges", spanOptions("checkChanges"))(function* (path, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* attempt("checkChanges", () => client.checkChanges(path, options));
+			return yield* attempt("checkChanges", (client) => client.checkChanges(path, options));
 		}),
 		setEnvVars: Effect.fn("Sandbox.setEnvVars", spanOptions("setEnvVars"))(function* (envVars) {
-			return yield* attempt("setEnvVars", () => client.setEnvVars(envVars));
+			return yield* attempt("setEnvVars", (client) => client.setEnvVars(envVars));
 		}),
 		exposePort: Effect.fn("Sandbox.exposePort", spanOptions("exposePort"))(function* (port, options) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* attempt("exposePort", () => client.exposePort(port, options));
+			return yield* attempt("exposePort", (client) => client.exposePort(port, options));
 		}),
 		unexposePort: Effect.fn("Sandbox.unexposePort", spanOptions("unexposePort"))(function* (port) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* attempt("unexposePort", () => client.unexposePort(port));
+			return yield* attempt("unexposePort", (client) => client.unexposePort(port));
 		}),
 		getExposedPorts: Effect.fn("Sandbox.getExposedPorts", spanOptions("getExposedPorts"))(function* (hostname) {
-			return yield* attempt("getExposedPorts", () => client.getExposedPorts(hostname));
+			return yield* attempt("getExposedPorts", (client) => client.getExposedPorts(hostname));
 		}),
 		isPortExposed: Effect.fn("Sandbox.isPortExposed", spanOptions("isPortExposed"))(function* (port) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* attempt("isPortExposed", () => client.isPortExposed(port));
+			return yield* attempt("isPortExposed", (client) => client.isPortExposed(port));
 		}),
 		validatePortToken: Effect.fn("Sandbox.validatePortToken", spanOptions("validatePortToken"))(function* (port, token) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* attempt("validatePortToken", () => client.validatePortToken(port, token));
+			return yield* attempt("validatePortToken", (client) => client.validatePortToken(port, token));
 		}),
 		containerFetch: Effect.fn("Sandbox.containerFetch", spanOptions("containerFetch"))(function* (requestOrUrl, port) {
-			return yield* attempt("containerFetch", () => client.containerFetch(requestOrUrl, port));
+			return yield* attempt("containerFetch", (client) => client.containerFetch(requestOrUrl, port));
 		}),
 		wsConnect: Effect.fn("Sandbox.wsConnect", spanOptions("wsConnect"))(function* (request, port) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* attempt("wsConnect", () => client.wsConnect(request, port));
+			return yield* attempt("wsConnect", (client) => client.wsConnect(request, port));
 		}),
 		mountBucket: Effect.fn("Sandbox.mountBucket", spanOptions("mountBucket"))(function* (bucket, mountPath, options) {
 			yield* Effect.annotateCurrentSpan({
 				bucket,
 				mountPath
 			});
-			return yield* attempt("mountBucket", () => client.mountBucket(bucket, mountPath, options));
+			return yield* attempt("mountBucket", (client) => client.mountBucket(bucket, mountPath, options));
 		}),
 		unmountBucket: Effect.fn("Sandbox.unmountBucket", spanOptions("unmountBucket"))(function* (mountPath) {
 			yield* Effect.annotateCurrentSpan("mountPath", mountPath);
-			return yield* attempt("unmountBucket", () => client.unmountBucket(mountPath));
+			return yield* attempt("unmountBucket", (client) => client.unmountBucket(mountPath));
 		}),
 		createBackup: Effect.fn("Sandbox.createBackup", spanOptions("createBackup"))(function* (options) {
 			yield* Effect.annotateCurrentSpan("dir", options.dir);
-			return yield* attempt("createBackup", () => client.createBackup(options));
+			return yield* attempt("createBackup", (client) => client.createBackup(options));
 		}),
 		restoreBackup: Effect.fn("Sandbox.restoreBackup", spanOptions("restoreBackup"))(function* (backup) {
 			yield* Effect.annotateCurrentSpan({
 				backupId: backup.id,
 				dir: backup.dir
 			});
-			return yield* attempt("restoreBackup", () => client.restoreBackup(backup));
+			return yield* attempt("restoreBackup", (client) => client.restoreBackup(backup));
 		}),
 		createTerminal: Effect.fn("Sandbox.createTerminal", spanOptions("createTerminal"))(function* (options) {
-			const terminal = yield* attempt("createTerminal", () => client.createTerminal(options));
-			return makeTerminalHandle(definition, instance, terminal, target);
+			return yield* attempt("createTerminal", (client, _signal, target) => client.createTerminal(options).then((terminal) => makeTerminalHandle(definition, instance, terminal, target)));
 		}),
 		getTerminal: Effect.fn("Sandbox.getTerminal", spanOptions("getTerminal"))(function* (id) {
-			const terminal = yield* attempt("getTerminal", () => client.getTerminal(id));
-			return Option.map(Option.fromNullishOr(terminal), (found) => makeTerminalHandle(definition, instance, found, target));
+			return yield* attempt("getTerminal", (client, _signal, target) => client.getTerminal(id).then((terminal) => Option.map(Option.fromNullishOr(terminal), (found) => makeTerminalHandle(definition, instance, found, target))));
 		}),
-		listTerminals: attempt("listTerminals", () => client.listTerminals()).pipe(Effect.map((terminals) => terminals.map((terminal) => makeTerminalHandle(definition, instance, terminal, target))), Effect.withSpan("Sandbox.listTerminals", spanOptions("listTerminals"))),
+		listTerminals: attempt("listTerminals", (client, _signal, target) => client.listTerminals().then((terminals) => terminals.map((terminal) => makeTerminalHandle(definition, instance, terminal, target)))).pipe(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* attempt("tunnels.get", () => client.tunnels.get(port, options));
+				return yield* attempt("tunnels.get", (client) => client.tunnels.get(port, options));
 			}),
-			list: attempt("tunnels.list", () => client.tunnels.list()).pipe(Effect.withSpan("Sandbox.tunnels.list", spanOptions("tunnels.list"))),
+			list: attempt("tunnels.list", (client) => 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* attempt("tunnels.destroy", () => client.tunnels.destroy(portOrInfo));
+				return yield* attempt("tunnels.destroy", (client) => client.tunnels.destroy(portOrInfo));
 			})
 		},
 		start: Effect.fn("Sandbox.start", spanOptions("start"))(function* (options) {
-			return yield* attempt("start", () => client.start(options));
+			return yield* attempt("start", (client) => client.start(options));
 		}),
 		stop: Effect.fn("Sandbox.stop", spanOptions("stop"))(function* (signal) {
-			return yield* attempt("stop", () => client.stop(signal));
+			return yield* attempt("stop", (client) => client.stop(signal));
 		}),
-		destroy: attempt("destroy", () => client.destroy()).pipe(Effect.withSpan("Sandbox.destroy", spanOptions("destroy")))
+		destroy: attempt("destroy", (client) => client.destroy()).pipe(Effect.withSpan("Sandbox.destroy", spanOptions("destroy")))
 	};
 };
 /**
@@ -315,30 +314,35 @@ const makeClient = (definition) => (namespace) => {
 		} })(function* (name, options) {
 			yield* Effect.annotateCurrentSpan("instance", name);
 			const sandboxModule = yield* importSandboxModule(definition, name);
-			const targets = yield* Effect.serviceOption(CurrentTargets);
-			const scopedNamespace = yield* get(namespace, "sandbox-namespace", () => {
-				const adapter = {
-					idFromName: (name) => namespace.idFromName(name),
-					get: (id, options) => Option.isSome(targets) ? targets.value.get(adapter, JSON.stringify([id.toString(), options]), () => namespace.get(id, options)) : namespace.get(id, options)
-				};
-				return adapter;
-			}).pipe(Effect.mapError((error) => new SandboxOperationError({
-				binding: definition.binding,
-				instance: name,
-				operation: "get",
-				cause: error.cause
-			})));
-			const nativeNamespace = scopedNamespace;
-			const client = yield* Effect.try({
-				try: () => sandboxModule.getSandbox(nativeNamespace, name, options),
-				catch: (cause) => new SandboxOperationError({
+			const resolve = Effect.gen(function* () {
+				const targets = yield* Effect.serviceOption(CurrentTargets);
+				const scopedNamespace = yield* get(namespace, "sandbox-namespace", () => {
+					const adapter = {
+						idFromName: (name) => namespace.idFromName(name),
+						get: (id, options) => Option.isSome(targets) ? targets.value.get(adapter, JSON.stringify([id.toString(), options]), () => namespace.get(id, options)) : namespace.get(id, options)
+					};
+					return adapter;
+				}).pipe(Effect.mapError((error) => new SandboxOperationError({
 					binding: definition.binding,
 					instance: name,
 					operation: "get",
-					cause
-				})
+					cause: error.cause
+				})));
+				const nativeNamespace = scopedNamespace;
+				return {
+					client: yield* Effect.try({
+						try: () => sandboxModule.getSandbox(nativeNamespace, name, options),
+						catch: (cause) => new SandboxOperationError({
+							binding: definition.binding,
+							instance: name,
+							operation: "get",
+							cause
+						})
+					}),
+					target: scopedNamespace
+				};
 			});
-			return makeSandboxClient(client, definition, name, scopedNamespace);
+			return makeSandboxClient(resolve, definition, name);
 		}),
 		rawUnsafe: Effect.succeed(namespace)
 	};

package/dist/index.d.mts

@@ -24,6 +24,8 @@ import { BrowserRendering_d_exports } from "./BrowserRendering.mjs";
 import { Cache_d_exports } from "./Cache.mjs";
 import { CloudflareOtlp_d_exports } from "./CloudflareOtlp.mjs";
 import { CloudflareTracer_d_exports } from "./CloudflareTracer.mjs";
+import { DurableObjectContainer_d_exports } from "./DurableObjectContainer.mjs";
+import { ContainerFiles_d_exports } from "./ContainerFiles.mjs";
 import { D1_d_exports } from "./D1.mjs";
 import { DurableObjectAlarm_d_exports } from "./DurableObjectAlarm.mjs";
 import { DurableObjectDefinition_d_exports } from "./DurableObjectDefinition.mjs";
@@ -40,4 +42,4 @@ import { Vectorize_d_exports } from "./Vectorize.mjs";
 import { WebTransport_d_exports } from "./WebTransport.mjs";
 import { WorkflowDefinition_d_exports } from "./WorkflowDefinition.mjs";
 import { Workflow_d_exports } from "./Workflow.mjs";
-export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Artifacts_d_exports as Artifacts, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, CloudflareTracer_d_exports as CloudflareTracer, ContainerNamespace_d_exports as ContainerNamespace, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, RpcTargets_d_exports as RpcTargets, RpcTracing_d_exports as RpcTracing, RpcWebSocketClient_d_exports as RpcWebSocketClient, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, WebTransport_d_exports as WebTransport, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };
+export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Artifacts_d_exports as Artifacts, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, Cache_d_exports as Cache, CloudflareOtlp_d_exports as CloudflareOtlp, CloudflareTracer_d_exports as CloudflareTracer, ContainerFiles_d_exports as ContainerFiles, ContainerNamespace_d_exports as ContainerNamespace, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectContainer_d_exports as DurableObjectContainer, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Environment_d_exports as Environment, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, RpcTargets_d_exports as RpcTargets, RpcTracing_d_exports as RpcTracing, RpcWebSocketClient_d_exports as RpcWebSocketClient, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, WebTransport_d_exports as WebTransport, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };

package/dist/index.mjs

@@ -11,6 +11,8 @@ import { DurableObjectWebSocket_exports } from "./DurableObjectWebSocket.mjs";
 import { DurableObjectState_exports } from "./DurableObjectState.mjs";
 import { CloudflareOtlp_exports } from "./CloudflareOtlp.mjs";
 import { CloudflareTracer_exports } from "./CloudflareTracer.mjs";
+import { DurableObjectContainer_exports } from "./DurableObjectContainer.mjs";
+import { ContainerFiles_exports } from "./ContainerFiles.mjs";
 import { RpcTargets_exports } from "./RpcTargets.mjs";
 import { ContainerNamespace_exports } from "./ContainerNamespace.mjs";
 import { D1_exports } from "./D1.mjs";
@@ -40,4 +42,4 @@ import { WebTransport_exports } from "./WebTransport.mjs";
 import { WorkflowBinding_exports } from "./WorkflowBinding.mjs";
 import { WorkflowDefinition_exports } from "./WorkflowDefinition.mjs";
 import { Workflow_exports } from "./Workflow.mjs";
-export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, CloudflareTracer_exports as CloudflareTracer, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, RpcTargets_exports as RpcTargets, RpcTracing_exports as RpcTracing, RpcWebSocketClient_exports as RpcWebSocketClient, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, CloudflareTracer_exports as CloudflareTracer, ContainerFiles_exports as ContainerFiles, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectContainer_exports as DurableObjectContainer, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, RpcTargets_exports as RpcTargets, RpcTracing_exports as RpcTracing, RpcWebSocketClient_exports as RpcWebSocketClient, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.48.0",
+  "version": "0.50.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -78,6 +78,7 @@
     "@cloudflare/computer": "0.2.0",
     "@cloudflare/containers": "catalog:",
     "@cloudflare/sandbox": "0.13.0-next.738.2",
+    "@cloudflare/sandbox-v1": "npm:@cloudflare/sandbox@1.0.0",
     "@cloudflare/vitest-plugin": "catalog:",
     "@cloudflare/workers-types": "catalog:",
     "@effect/platform-node": "catalog:",
@@ -96,9 +97,9 @@
   },
   "peerDependencies": {
     "@cloudflare/computer": "^0.2.0",
-    "@cloudflare/sandbox": "^0.13.0-next.738.2",
+    "@cloudflare/sandbox": "^0.13.0-next.738.2 || ^1.0.0",
     "@cloudflare/vitest-plugin": "^1.0.0",
-    "@cloudflare/workers-types": "^5.20260825.1",
+    "@cloudflare/workers-types": "^5.20260926.1",
     "@effect/sql-d1": "^4.0.0-rc.115",
     "@effect/sql-pg": "^4.0.0-rc.115",
     "@effect/sql-sqlite-do": "^4.0.0-rc.115",

package/src/ContainerFiles.ts

@@ -0,0 +1,162 @@
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+
+import { ContainerError } from "./DurableObjectContainer";
+
+export type FileContent =
+  | string
+  | ArrayBuffer
+  | ArrayBufferView
+  | Blob
+  | ReadableStream<Uint8Array>;
+export type FileType =
+  | "file"
+  | "directory"
+  | "symlink"
+  | "blockDevice"
+  | "characterDevice"
+  | "fifo"
+  | "socket";
+
+export interface FileOperationOptions {
+  readonly cwd?: string;
+  readonly user?: string;
+}
+
+export interface MkdirOptions extends FileOperationOptions {
+  readonly recursive?: boolean;
+}
+
+export interface RemoveOptions extends FileOperationOptions {
+  readonly recursive?: boolean;
+  readonly force?: boolean;
+}
+
+export interface FileStat {
+  readonly type: FileType;
+  readonly size: bigint;
+  readonly mode: number;
+  readonly uid: number;
+  readonly gid: number;
+  readonly accessedAt: Date;
+  readonly modifiedAt: Date;
+  readonly changedAt: Date;
+}
+
+export interface DirectoryEntry {
+  readonly name: string;
+  readonly type: FileType;
+}
+
+type WithSignal<A> = A & { readonly signal?: AbortSignal };
+
+/** Structural contract of Sandbox SDK 1.x `Files`, without loading an SDK version. */
+export interface FilesResource {
+  readFile(path: string, options?: WithSignal<FileOperationOptions>): Promise<Response>;
+  writeFile(
+    path: string,
+    content: FileContent,
+    options?: WithSignal<FileOperationOptions>,
+  ): Promise<void>;
+  stat(path: string, options?: WithSignal<FileOperationOptions>): Promise<FileStat>;
+  lstat(path: string, options?: WithSignal<FileOperationOptions>): Promise<FileStat>;
+  readDirectory(
+    path: string,
+    options?: WithSignal<FileOperationOptions>,
+  ): Promise<ReadonlyArray<DirectoryEntry>>;
+  mkdir(path: string, options?: WithSignal<MkdirOptions>): Promise<void>;
+  rename(
+    source: string,
+    destination: string,
+    options?: WithSignal<FileOperationOptions>,
+  ): Promise<void>;
+  remove(path: string, options?: WithSignal<RemoveOptions>): Promise<void>;
+}
+
+export interface ContainerFiles {
+  readonly raw: FilesResource;
+  /** The caller consumes or cancels the response body. Late failures retain native SDK errors. */
+  readonly readFile: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<Response, ContainerError>;
+  /** Includes failures that arrive while reading the response body. */
+  readonly readFileStream: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Stream.Stream<Uint8Array, ContainerError>;
+  readonly readFileString: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<string, ContainerError>;
+  readonly writeFile: (
+    path: string,
+    content: FileContent,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<void, ContainerError>;
+  readonly stat: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<FileStat, ContainerError>;
+  readonly lstat: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<FileStat, ContainerError>;
+  readonly readDirectory: (
+    path: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<ReadonlyArray<DirectoryEntry>, ContainerError>;
+  readonly mkdir: (path: string, options?: MkdirOptions) => Effect.Effect<void, ContainerError>;
+  readonly rename: (
+    source: string,
+    destination: string,
+    options?: FileOperationOptions,
+  ) => Effect.Effect<void, ContainerError>;
+  readonly remove: (path: string, options?: RemoveOptions) => Effect.Effect<void, ContainerError>;
+}
+
+const attempt = <A>(operation: string, evaluate: (signal: AbortSignal) => Promise<A>) =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => new ContainerError({ operation: `files.${operation}`, cause }),
+  });
+
+/** Pass `new Files(container.raw)` from SDK 1.x. The image must supply its matching sandbox-shim. */
+export const fromFiles = (files: FilesResource): ContainerFiles => {
+  const readFile = (path: string, options?: FileOperationOptions) =>
+    attempt("readFile", (signal) => files.readFile(path, { ...options, signal }));
+  const readFileStream = (path: string, options?: FileOperationOptions) =>
+    Stream.unwrap(
+      Effect.map(readFile(path, options), (response) => {
+        const body = response.body;
+
+        return body === null
+          ? Stream.empty
+          : Stream.fromReadableStream({
+              evaluate: () => body,
+              onError: (cause) => new ContainerError({ operation: "files.readFile", cause }),
+            });
+      }),
+    );
+
+  return {
+    raw: files,
+    readFile,
+    readFileStream,
+    readFileString: (path, options) =>
+      readFileStream(path, options).pipe(Stream.decodeText(), Stream.mkString),
+    writeFile: (path, content, options) =>
+      attempt("writeFile", (signal) => files.writeFile(path, content, { ...options, signal })),
+    stat: (path, options) => attempt("stat", (signal) => files.stat(path, { ...options, signal })),
+    lstat: (path, options) =>
+      attempt("lstat", (signal) => files.lstat(path, { ...options, signal })),
+    readDirectory: (path, options) =>
+      attempt("readDirectory", (signal) => files.readDirectory(path, { ...options, signal })),
+    mkdir: (path, options) =>
+      attempt("mkdir", (signal) => files.mkdir(path, { ...options, signal })),
+    rename: (source, destination, options) =>
+      attempt("rename", (signal) => files.rename(source, destination, { ...options, signal })),
+    remove: (path, options) =>
+      attempt("remove", (signal) => files.remove(path, { ...options, signal })),
+  };
+};

package/src/ContainerNamespace.ts

@@ -60,10 +60,12 @@ export const ContainerState = S.Union([
 export type ContainerState = typeof ContainerState.Type;
 
 /**
- * Native Container stub shape exposed by a Container namespace binding.
+ * RPC stub exposed by the legacy `@cloudflare/containers` Container class.
  *
  * This is structural so using Container bindings does not make
  * `@cloudflare/containers` a runtime dependency of effect-cf.
+ * Use `DurableObjectContainer` inside a Durable Object for the native
+ * `ctx.container` API and the `durable_object` scheduling policy.
  */
 export interface ContainerStub {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;