effect-cf 0.40.3 → 0.41.1

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,5 +1,6 @@
 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 { assumeEntrypointClass, defineEntrypointRpcMethods } from "./internal/Entrypoint.mjs";
@@ -61,15 +62,15 @@ const renderFetchSuccess = (effect, eventLayer) => Effect.suspend(() => {
 			context
 		});
 	});
-	const telemetryMiddleware = HttpMiddleware.make((self) => Effect.gen(function* () {
+	const telemetryMiddleware = HttpMiddleware.make((self) => withScope(Effect.gen(function* () {
 		yield* Effect.addFinalizer(() => scheduleTelemetryFlush);
 		return yield* self;
-	}));
-	const handled = eventLayer === void 0 ? HttpEffect.toHandled(httpApp, handleResponse, telemetryMiddleware) : Effect.flatMap(References.TracerEnabled, (tracerEnabled) => HttpEffect.toHandled(httpApp, handleResponse, HttpMiddleware.make((self) => Effect.provideService(Effect.gen(function* () {
+	})));
+	const handled = eventLayer === void 0 ? HttpEffect.toHandled(httpApp, handleResponse, telemetryMiddleware) : Effect.flatMap(References.TracerEnabled, (tracerEnabled) => HttpEffect.toHandled(httpApp, handleResponse, HttpMiddleware.make((self) => withScope(Effect.provideService(Effect.gen(function* () {
 		const context = yield* Layer.build(Layer.fresh(eventLayer));
 		yield* Effect.addFinalizer(() => Effect.provideContext(scheduleTelemetryFlush, context));
 		return yield* HttpMiddleware.tracer(self).pipe(Effect.onExit(() => Effect.yieldNow), Effect.provideContext(context));
-	}), References.TracerEnabled, tracerEnabled))).pipe(Effect.withTracerEnabled(false)));
+	}), References.TracerEnabled, tracerEnabled)))).pipe(Effect.withTracerEnabled(false)));
 	const captured = () => nativeResponse ?? webResponse ?? new Response(null, { status: 500 });
 	return Effect.matchCause(handled, {
 		onFailure: captured,

package/dist/Workflow.mjs

@@ -1,6 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
 import { fromExecutionContext } from "./internal/WorkerContext.mjs";
+import { withScope } from "./RpcTargets.mjs";
 import { assumeEntrypointClass } from "./internal/Entrypoint.mjs";
 import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
 import { ExecutionContext, WorkerContext } from "./Worker.mjs";
@@ -74,7 +75,7 @@ const fromWorkflowStep = (step) => ({
 			return yield* Effect.tryPromise({
 				try: () => {
 					const run = (stepContext) => {
-						const stepEffect = Effect.scoped(Effect.provideService(effect, WorkflowStepContext$1, stepContext));
+						const stepEffect = Effect.scoped(withScope(Effect.provideService(effect, WorkflowStepContext$1, stepContext)));
 						return runPromise(exposeCloudflareNonRetryableError(Effect.provideContext(stepEffect, context)));
 					};
 					const rawStep = step;

package/dist/index.d.mts

@@ -34,8 +34,9 @@ import { Email_d_exports } from "./Email.mjs";
 import { Images_d_exports } from "./Images.mjs";
 import { Kv_d_exports } from "./Kv.mjs";
 import { R2_d_exports } from "./R2.mjs";
+import { RpcTargets_d_exports } from "./RpcTargets.mjs";
 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, RpcTracing_d_exports as RpcTracing, 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, 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, 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,7 @@ 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";
@@ -38,4 +39,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, RpcTracing_exports as RpcTracing, 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, 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, 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/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/dist/internal/Runtime.mjs

@@ -1,4 +1,5 @@
 import { WorkerConfig, WorkerEnvironment } from "../Environment.mjs";
+import { withScope } from "../RpcTargets.mjs";
 import { provideEntrypointServices } from "./Entrypoint.mjs";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -21,10 +22,10 @@ const makeEntrypointRuntime = (layer, env, services) => {
 function runEventPromise(...args) {
 	const [runtime, effect, eventLayer, parent] = args;
 	if (eventLayer === void 0) {
-		const event = Effect.scoped(effect);
+		const event = Effect.scoped(withScope(effect));
 		return runtime.runPromise(parent === void 0 ? event : Effect.withParentSpan(event, parent));
 	}
-	const event = Effect.scoped(effect.pipe(Effect.provide(eventLayer, { local: true })));
+	const event = Effect.scoped(withScope(effect.pipe(Effect.provide(eventLayer, { local: true }))));
 	return runtime.runPromise(parent === void 0 ? event : Effect.withParentSpan(event, parent));
 }
 //#endregion

package/package.json

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

package/src/ContainerNamespace.ts

@@ -6,6 +6,7 @@ import * as S from "effect/Schema";
 import type { Layer } from "effect";
 
 import * as Binding from "./Binding";
+import * as RpcTargets from "./RpcTargets";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
@@ -231,6 +232,7 @@ const tryContainerPromise = <A>(
   instance: string,
   operation: string,
   evaluate: () => Promise<A>,
+  target: ContainerStub,
 ): Effect.Effect<A, ContainerOperationError> =>
   Effect.tryPromise({
     try: evaluate,
@@ -241,13 +243,15 @@ const tryContainerPromise = <A>(
         operation,
         cause,
       }),
-  });
+  }).pipe(Effect.tapCause(() => RpcTargets.invalidate(target)));
 
 const makeInstanceClient = <Stub extends ContainerStub>(
   definition: ContainerNamespaceDefinition,
   instance: string,
   stub: Stub,
 ): ContainerInstanceClient<Stub> => {
+  const attempt = <A>(operation: string, evaluate: () => Promise<A>) =>
+    tryContainerPromise(definition, instance, operation, evaluate, stub);
   const spanOptions = (operation: string) => ({
     attributes: { binding: definition.binding, instance, operation },
   });
@@ -256,9 +260,7 @@ const makeInstanceClient = <Stub extends ContainerStub>(
       `ContainerNamespace.${operation}`,
       spanOptions(operation),
     )(function* (hosts: ReadonlyArray<string>) {
-      return yield* tryContainerPromise(definition, instance, operation, () =>
-        stub[operation]([...hosts]),
-      );
+      return yield* attempt(operation, () => stub[operation]([...hosts]));
     });
   const hostnameOperation = (
     operation: "allowHost" | "denyHost" | "removeAllowedHost" | "removeDeniedHost",
@@ -267,14 +269,12 @@ const makeInstanceClient = <Stub extends ContainerStub>(
       `ContainerNamespace.${operation}`,
       spanOptions(operation),
     )(function* (hostname: string) {
-      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(
+    state: attempt("state", () => stub.getState()).pipe(
       Effect.flatMap(S.decodeUnknownEffect(ContainerState)),
       Effect.mapError((cause) =>
         cause instanceof ContainerOperationError
@@ -292,41 +292,33 @@ const makeInstanceClient = <Stub extends ContainerStub>(
       "ContainerNamespace.fetch",
       spanOptions("fetch"),
     )(function* (input: RequestInfo | URL, init?: RequestInit) {
-      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?: ContainerStartOptions, waitOptions?: ContainerWaitOptions) {
-      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?: ContainerStartAndWaitForPortsOptions) {
-      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: ContainerWaitOptions) {
-      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?: ContainerStopSignal) {
-      return yield* tryContainerPromise(definition, instance, "stop", () => stub.stop(signal));
+      return yield* attempt("stop", () => stub.stop(signal));
     }),
-    destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy()).pipe(
+    destroy: attempt("destroy", () => stub.destroy()).pipe(
       Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy")),
     ),
     setAllowedHosts: hostListOperation("setAllowedHosts"),
@@ -352,23 +344,24 @@ export const makeClient =
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) =>
-      Effect.try({
-        try: () =>
-          makeInstanceClient(
-            definition,
-            name,
-            // SAFETY: getByName has a single call signature, so its return type is
-            // exactly the namespace's stub type.
-            namespace.getByName(name, options) as ContainerStubOf<Namespace>,
-          ),
-        catch: (cause) =>
-          new ContainerOperationError({
-            binding: definition.binding,
-            instance: name,
-            operation: "getByName",
-            cause,
-          }),
-      });
+      RpcTargets.get(
+        namespace,
+        JSON.stringify(["container", name, options]),
+        () =>
+          // SAFETY: getByName returns the namespace's declared native stub type.
+          namespace.getByName(name, options) as ContainerStubOf<Namespace>,
+      ).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: string,