effect-cf 0.41.0 → 0.41.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # effect-cf
 
+## 0.41.1
+
+### Patch Changes
+
+- [#161](https://github.com/danieljvdm/effect-cf/pull/161) [`a627f80`](https://github.com/danieljvdm/effect-cf/commit/a627f80449bf40227bddf917640aae9574faa563) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Retain Sandbox and Container RPC channels for each invocation so repeated lookups after callbacks do not exhaust Cloudflare's subrequest depth. Sandbox configuration continues to apply on each lookup, and failed channels are replaced on subsequent acquisition.
+
 ## 0.41.0
 
 ### Minor Changes

package/dist/ContainerNamespace.mjs

@@ -1,6 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { layer as layer$1 } from "./Binding.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { get, invalidate } from "./RpcTargets.mjs";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -37,7 +38,7 @@ var ContainerOperationError = class extends Data.TaggedError("ContainerOperation
 		return `Container ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
 	}
 };
-const tryContainerPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
+const tryContainerPromise = (definition, instance, operation, evaluate, target) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => new ContainerOperationError({
 		binding: definition.binding,
@@ -45,43 +46,44 @@ const tryContainerPromise = (definition, instance, operation, evaluate) => Effec
 		operation,
 		cause
 	})
-});
+}).pipe(Effect.tapCause(() => invalidate(target)));
 const makeInstanceClient = (definition, instance, stub) => {
+	const attempt = (operation, evaluate) => tryContainerPromise(definition, instance, operation, evaluate, stub);
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
 		operation
 	} });
 	const hostListOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hosts) {
-		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation]([...hosts]));
+		return yield* attempt(operation, () => stub[operation]([...hosts]));
 	});
 	const hostnameOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hostname) {
-		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation](hostname));
+		return yield* attempt(operation, () => stub[operation](hostname));
 	});
 	return {
 		rawUnsafe: Effect.succeed(stub),
-		state: tryContainerPromise(definition, instance, "state", () => stub.getState()).pipe(Effect.flatMap(S.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
+		state: attempt("state", () => stub.getState()).pipe(Effect.flatMap(S.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
 			binding: definition.binding,
 			instance,
 			operation: "state",
 			cause
 		})), Effect.withSpan("ContainerNamespace.state", spanOptions("state"))),
 		fetch: Effect.fn("ContainerNamespace.fetch", spanOptions("fetch"))(function* (input, init) {
-			return yield* tryContainerPromise(definition, instance, "fetch", () => stub.fetch(input, init));
+			return yield* attempt("fetch", () => stub.fetch(input, init));
 		}),
 		start: Effect.fn("ContainerNamespace.start", spanOptions("start"))(function* (options, waitOptions) {
-			return yield* tryContainerPromise(definition, instance, "start", () => stub.start(options, waitOptions));
+			return yield* attempt("start", () => stub.start(options, waitOptions));
 		}),
 		startAndWaitForPorts: Effect.fn("ContainerNamespace.startAndWaitForPorts", spanOptions("startAndWaitForPorts"))(function* (options) {
-			return yield* tryContainerPromise(definition, instance, "startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
+			return yield* attempt("startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
 		}),
 		waitForPort: Effect.fn("ContainerNamespace.waitForPort", spanOptions("waitForPort"))(function* (options) {
-			return yield* tryContainerPromise(definition, instance, "waitForPort", () => stub.waitForPort(options));
+			return yield* attempt("waitForPort", () => stub.waitForPort(options));
 		}),
 		stop: Effect.fn("ContainerNamespace.stop", spanOptions("stop"))(function* (signal) {
-			return yield* tryContainerPromise(definition, instance, "stop", () => stub.stop(signal));
+			return yield* attempt("stop", () => stub.stop(signal));
 		}),
-		destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy"))),
+		destroy: attempt("destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy"))),
 		setAllowedHosts: hostListOperation("setAllowedHosts"),
 		setDeniedHosts: hostListOperation("setDeniedHosts"),
 		allowHost: hostnameOperation("allowHost"),
@@ -92,15 +94,16 @@ const makeInstanceClient = (definition, instance, stub) => {
 };
 const isContainerNamespaceResource = (value) => Predicate.hasProperty(value, "getByName") && Predicate.isFunction(value.getByName);
 const makeClient = (definition) => (namespace) => {
-	const getByName = (name, options) => Effect.try({
-		try: () => makeInstanceClient(definition, name, namespace.getByName(name, options)),
-		catch: (cause) => new ContainerOperationError({
-			binding: definition.binding,
-			instance: name,
-			operation: "getByName",
-			cause
-		})
-	});
+	const getByName = (name, options) => get(namespace, JSON.stringify([
+		"container",
+		name,
+		options
+	]), () => namespace.getByName(name, options)).pipe(Effect.map((stub) => makeInstanceClient(definition, name, stub)), Effect.mapError((error) => new ContainerOperationError({
+		binding: definition.binding,
+		instance: name,
+		operation: "getByName",
+		cause: error.cause
+	})));
 	const byName = (name, options) => {
 		const instance = getByName(name, options);
 		return {

package/dist/DurableObjectNamespace.mjs

@@ -1,8 +1,8 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { layer as layer$1 } from "./Binding.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
-import { decodeSuccess, encodeArgs } from "./RpcDefinition.mjs";
 import { get, invalidate } from "./RpcTargets.mjs";
+import { decodeSuccess, encodeArgs } from "./RpcDefinition.mjs";
 import { withRpcClientSpan, withRpcTraceContext } from "./RpcTracing.mjs";
 import { invokeRpcMethod } from "./internal/RpcInvocation.mjs";
 import { resolve, scoped } from "./Rpc.mjs";

package/dist/RpcTargets.mjs

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import * as Context from "effect/Context";
+import { CurrentTargets } from "./internal/RpcTargets.mjs";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
@@ -12,7 +12,6 @@ var RpcTargets_exports = /* @__PURE__ */ __exportAll({
 });
 /** A native RPC target could not be constructed. */
 var RpcTargetError = class extends Data.TaggedError("RpcTargetError") {};
-var CurrentTargets = class extends Context.Service()("effect-cf/RpcTargets") {};
 /**
 * Reuse a native RPC target within the current invocation. Native Durable Object
 * stubs capture the calling request's channel when created. Recreating a stub

package/dist/Sandbox.mjs

@@ -1,6 +1,8 @@
 import { WorkerEnvironment } from "./Environment.mjs";
 import { layer as layer$1 } from "./Binding.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { CurrentTargets } from "./internal/RpcTargets.mjs";
+import { get, invalidate } from "./RpcTargets.mjs";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -14,7 +16,7 @@ var SandboxOperationError = class extends Data.TaggedError("SandboxOperationErro
 		return `Sandbox ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
 	}
 };
-const trySandboxPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
+const trySandboxPromise = (definition, instance, operation, evaluate, target) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => new SandboxOperationError({
 		binding: definition.binding,
@@ -22,8 +24,8 @@ const trySandboxPromise = (definition, instance, operation, evaluate) => Effect.
 		operation,
 		cause
 	})
-});
-const sandboxStream = (definition, instance, operation, acquire) => Stream.unwrap(Effect.map(trySandboxPromise(definition, instance, operation, acquire), (readable) => Stream.fromReadableStream({
+}).pipe(Effect.tapCause(() => target === void 0 ? Effect.void : invalidate(target)));
+const sandboxStream = (definition, instance, operation, acquire, target) => Stream.unwrap(Effect.map(trySandboxPromise(definition, instance, operation, acquire, target), (readable) => Stream.fromReadableStream({
 	evaluate: () => readable,
 	onError: (cause) => new SandboxOperationError({
 		binding: definition.binding,
@@ -31,7 +33,7 @@ const sandboxStream = (definition, instance, operation, acquire) => Stream.unwra
 		operation,
 		cause
 	})
-})));
+}))).pipe(Stream.tapCause(() => invalidate(target)));
 const decodeSseData = (payload) => {
 	if (payload === "[DONE]" || payload.trim() === "") return [];
 	try {
@@ -53,7 +55,9 @@ const decodeSseEvents = (bytes) => bytes.pipe(Stream.decodeText(), Stream.splitL
 	}
 	return [pending, []];
 }, { onHalt: (pending) => pending.length > 0 ? decodeSseData(pending.join("\n")) : [] }));
-const makeProcessHandle = (definition, instance, process) => {
+const makeProcessHandle = (definition, instance, process, target) => {
+	const attempt = (operation, evaluate) => trySandboxPromise(definition, instance, operation, evaluate, target);
+	const stream = (operation, acquire) => sandboxStream(definition, instance, operation, acquire, target);
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
@@ -64,49 +68,51 @@ const makeProcessHandle = (definition, instance, process) => {
 		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({
+		status: attempt("process.status", () => process.status()).pipe(Effect.withSpan("Sandbox.process.status", spanOptions("process.status"))),
+		exitCode: attempt("process.exitCode", () => process.exitCode).pipe(Effect.withSpan("Sandbox.process.exitCode", spanOptions("process.exitCode"))),
+		logs: (options) => stream("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, {
+			return yield* attempt("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({
+			return yield* attempt("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({
+			return yield* attempt("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({
+			return yield* attempt("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, {
+			return yield* attempt("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));
+			return yield* attempt("process.kill", () => process.kill(signal));
 		})
 	};
 };
-const makeTerminalHandle = (definition, instance, terminal) => {
+const makeTerminalHandle = (definition, instance, terminal, target) => {
+	const attempt = (operation, evaluate) => trySandboxPromise(definition, instance, operation, evaluate, target);
+	const stream = (operation, acquire) => sandboxStream(definition, instance, operation, acquire, target);
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
@@ -116,31 +122,34 @@ const makeTerminalHandle = (definition, instance, terminal) => {
 	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"))),
+		snapshot: attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("terminal.resize", () => terminal.resize(cols, rows));
 		}),
-		output: (options) => sandboxStream(definition, instance, "terminal.output", (signal) => terminal.output({
+		output: (options) => stream("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({
+			return yield* attempt("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"))),
+		interrupt: attempt("terminal.interrupt", () => terminal.interrupt()).pipe(Effect.withSpan("Sandbox.terminal.interrupt", spanOptions("terminal.interrupt"))),
+		terminate: attempt("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));
+			return yield* attempt("terminal.connect", () => terminal.connect(request, options));
 		})
 	};
 };
-const fromSandboxClient = (client, definition, instance) => {
+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 spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
@@ -149,135 +158,135 @@ const fromSandboxClient = (client, definition, instance) => {
 	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);
+			const process = yield* attempt("exec", () => client.exec(command, options));
+			return makeProcessHandle(definition, instance, process, target);
 		}),
 		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));
+			const process = yield* attempt("getProcess", () => client.getProcess(id));
+			return Option.map(Option.fromNullishOr(process), (found) => makeProcessHandle(definition, instance, found, target));
 		}),
-		listProcesses: trySandboxPromise(definition, instance, "listProcesses", () => client.listProcesses()).pipe(Effect.withSpan("Sandbox.listProcesses", spanOptions("listProcesses"))),
+		listProcesses: attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("readFile", () => client.readFile(path, options));
 		}),
-		readFileStream: (path) => sandboxStream(definition, instance, "readFileStream", () => client.readFileStream(path)),
+		readFileStream: (path) => stream("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("exists", () => client.exists(path));
 		}),
-		watch: (path, options) => decodeSseEvents(sandboxStream(definition, instance, "watch", () => client.watch(path, options))),
+		watch: (path, options) => decodeSseEvents(stream("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));
+			return yield* attempt("checkChanges", () => client.checkChanges(path, options));
 		}),
 		setEnvVars: Effect.fn("Sandbox.setEnvVars", spanOptions("setEnvVars"))(function* (envVars) {
-			return yield* trySandboxPromise(definition, instance, "setEnvVars", () => client.setEnvVars(envVars));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("unexposePort", () => client.unexposePort(port));
 		}),
 		getExposedPorts: Effect.fn("Sandbox.getExposedPorts", spanOptions("getExposedPorts"))(function* (hostname) {
-			return yield* trySandboxPromise(definition, instance, "getExposedPorts", () => client.getExposedPorts(hostname));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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));
+			return yield* attempt("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);
+			const terminal = yield* attempt("createTerminal", () => client.createTerminal(options));
+			return makeTerminalHandle(definition, instance, terminal, target);
 		}),
 		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));
+			const terminal = yield* attempt("getTerminal", () => client.getTerminal(id));
+			return Option.map(Option.fromNullishOr(terminal), (found) => makeTerminalHandle(definition, instance, found, target));
 		}),
-		listTerminals: trySandboxPromise(definition, instance, "listTerminals", () => client.listTerminals()).pipe(Effect.map((terminals) => terminals.map((terminal) => makeTerminalHandle(definition, instance, terminal))), Effect.withSpan("Sandbox.listTerminals", spanOptions("listTerminals"))),
+		listTerminals: attempt("listTerminals", () => client.listTerminals()).pipe(Effect.map((terminals) => terminals.map((terminal) => makeTerminalHandle(definition, instance, terminal, target))), 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));
+				return yield* attempt("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"))),
+			list: attempt("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));
+				return yield* attempt("tunnels.destroy", () => client.tunnels.destroy(portOrInfo));
 			})
 		},
 		start: Effect.fn("Sandbox.start", spanOptions("start"))(function* (options) {
-			return yield* trySandboxPromise(definition, instance, "start", () => client.start(options));
+			return yield* attempt("start", () => client.start(options));
 		}),
 		stop: Effect.fn("Sandbox.stop", spanOptions("stop"))(function* (signal) {
-			return yield* trySandboxPromise(definition, instance, "stop", () => client.stop(signal));
+			return yield* attempt("stop", () => client.stop(signal));
 		}),
-		destroy: trySandboxPromise(definition, instance, "destroy", () => client.destroy()).pipe(Effect.withSpan("Sandbox.destroy", spanOptions("destroy")))
+		destroy: attempt("destroy", () => client.destroy()).pipe(Effect.withSpan("Sandbox.destroy", spanOptions("destroy")))
 	};
 };
 /**
@@ -306,7 +315,20 @@ const makeClient = (definition) => (namespace) => {
 		} })(function* (name, options) {
 			yield* Effect.annotateCurrentSpan("instance", name);
 			const sandboxModule = yield* importSandboxModule(definition, name);
-			const nativeNamespace = namespace;
+			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({
@@ -316,7 +338,7 @@ const makeClient = (definition) => (namespace) => {
 					cause
 				})
 			});
-			return fromSandboxClient(client, definition, name);
+			return makeSandboxClient(client, definition, name, scopedNamespace);
 		}),
 		rawUnsafe: Effect.succeed(namespace)
 	};

package/dist/Worker.mjs

@@ -1,8 +1,8 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { fromExecutionContext } from "./internal/WorkerContext.mjs";
+import { withScope } from "./RpcTargets.mjs";
 import { fromMessage, fromMessageBatch } from "./Queue.mjs";
 import { reservedMethodNames as reservedMethodNames$1 } from "./RpcDefinition.mjs";
-import { withScope } from "./RpcTargets.mjs";
 import { assumeEntrypointClass, defineEntrypointRpcMethods } from "./internal/Entrypoint.mjs";
 import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
 import { scheduleTelemetryFlush as scheduleTelemetryFlush$1 } from "./internal/Telemetry.mjs";

package/dist/index.mjs

@@ -11,13 +11,13 @@ 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 { RpcTargets_exports } from "./RpcTargets.mjs";
 import { ContainerNamespace_exports } from "./ContainerNamespace.mjs";
 import { D1_exports } from "./D1.mjs";
 import { QueueBinding_exports } from "./QueueBinding.mjs";
 import { QueueDefinition_exports } from "./QueueDefinition.mjs";
 import { Queue_exports } from "./Queue.mjs";
 import { RpcDefinition_exports } from "./RpcDefinition.mjs";
-import { RpcTargets_exports } from "./RpcTargets.mjs";
 import { RpcTracing_exports } from "./RpcTracing.mjs";
 import { Rpc_exports } from "./Rpc.mjs";
 import { ServiceBinding_exports } from "./ServiceBinding.mjs";

package/dist/internal/RpcTargets.mjs

@@ -0,0 +1,5 @@
+import * as Context from "effect/Context";
+//#region src/internal/RpcTargets.ts
+var CurrentTargets = class extends Context.Service()("effect-cf/RpcTargets") {};
+//#endregion
+export { CurrentTargets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.41.0",
+  "version": "0.41.1",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {