effect-cf 0.40.2 → 0.41.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # effect-cf
 
+## 0.41.0
+
+### Minor Changes
+
+- [#159](https://github.com/danieljvdm/effect-cf/pull/159) [`8cbc534`](https://github.com/danieljvdm/effect-cf/commit/8cbc5344ffa2aa031b6d98a2845ca3b945cf7d5f) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Reuse Durable Object RPC targets within each invocation so callbacks cannot grow a new subrequest chain on every call. Incoming requests and durable retries retain separate target lifetimes. Expose RpcTargets for native RPC adapters sharing the same invocation boundary.
+
+## 0.40.3
+
+### Patch Changes
+
+- [#157](https://github.com/danieljvdm/effect-cf/pull/157) [`279eecd`](https://github.com/danieljvdm/effect-cf/commit/279eecd1a5ea9112e727497e0aac666142e7a7f8) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Prevent Durable Object SQLite transactions from stalling when a blocked owner timer precedes an Effect scheduler yield. Keep transaction isolation, rollback, and the caller's scheduler after the transaction completes.
+
 ## 0.40.2
 
 ### Patch Changes

package/dist/D1.d.mts

@@ -2,8 +2,8 @@ import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingService, BindingValidationError } from "./Binding.mjs";
 import * as Layer$1 from "effect/Layer";
 import { D1Client } from "@effect/sql-d1";
-import { Config } from "effect";
 import { SqlClient } from "effect/unstable/sql";
+import { Config } from "effect";
 declare namespace D1_d_exports {
   export { D1Definition, D1Service, D1SqlLayerOptions, Service, TypeId, make };
 }

package/dist/DurableObjectNamespace.mjs

@@ -2,6 +2,7 @@ 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 { withRpcClientSpan, withRpcTraceContext } from "./RpcTracing.mjs";
 import { invokeRpcMethod } from "./internal/RpcInvocation.mjs";
 import { resolve, scoped } from "./Rpc.mjs";
@@ -41,8 +42,16 @@ const makeClient = (definition) => {
 		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
 		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
 		const idFromString = (id) => Effect.sync(() => namespace.idFromString(id));
-		const get = (id, options) => Effect.sync(() => namespace.get(id, options));
-		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
+		const get$1 = (id, options) => get(namespace, JSON.stringify([
+			"id",
+			id.toString(),
+			options
+		]), () => namespace.get(id, options)).pipe(Effect.orDie);
+		const getByName = (name, options) => get(namespace, JSON.stringify([
+			"name",
+			name,
+			options
+		]), () => namespace.getByName(name, options)).pipe(Effect.orDie);
 		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
 		const fetch = (stub, input, init) => Effect.tryPromise({
 			try: (signal) => {
@@ -56,7 +65,7 @@ const makeClient = (definition) => {
 				binding: definition.binding,
 				cause
 			})
-		});
+		}).pipe(Effect.tapCause(() => invalidate(stub)));
 		const rpc = Effect.fnUntraced(function* (stub, method, ...args) {
 			const methodName = String(method);
 			const encodedArgs = definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
@@ -69,7 +78,7 @@ const makeClient = (definition) => {
 				binding: definition.binding,
 				method: methodName,
 				cause
-			}));
+			})).pipe(Effect.tapCause(() => invalidate(stub)));
 		});
 		const decodeSuccess$1 = Effect.fnUntraced(function* (methodName, value) {
 			if (definition.definition === void 0) return value;
@@ -81,7 +90,7 @@ const makeClient = (definition) => {
 		});
 		const call = Effect.fnUntraced(function* (stub, method, ...args) {
 			const methodName = String(method);
-			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.tapCause(() => invalidate(stub)), Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -91,7 +100,7 @@ const makeClient = (definition) => {
 		const scopedCall = Effect.fnUntraced(function* (stub, method, ...args) {
 			const methodName = String(method);
 			const result = yield* rpc(stub, method, ...args);
-			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			const value = yield* scoped(result).pipe(Effect.tapCause(() => invalidate(stub)), Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -101,14 +110,14 @@ const makeClient = (definition) => {
 		const directMethods = makeDirectMethods(definition.definition, {
 			call,
 			fetch,
-			get,
+			get: get$1,
 			getByName
 		});
 		return Object.assign(directMethods, {
 			newUniqueId,
 			idFromName,
 			idFromString,
-			get,
+			get: get$1,
 			getByName,
 			jurisdiction,
 			fetch,

package/dist/DurableObjectSqlite.mjs

@@ -1,16 +1,25 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { SqliteClient } from "@effect/sql-sqlite-do";
+import * as Scheduler from "effect/Scheduler";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import { SqlClient } from "effect/unstable/sql";
 //#region src/DurableObjectSqlite.ts
 var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
-const layer = (options) => Layer.unwrap(Effect.gen(function* () {
+const layer = (options) => Layer.effectContext(Effect.gen(function* () {
 	const state = yield* DurableObjectState;
-	return SqliteClient.layer({
+	const client = yield* SqliteClient.make({
 		...options,
 		storage: state.raw.storage
 	});
-}));
+	const original = client.withTransaction;
+	const scheduler = new Scheduler.MixedScheduler("sync");
+	const withTransaction = (body) => original(body).pipe(Effect.provideService(Scheduler.Scheduler, scheduler));
+	Object.assign(client, { withTransaction });
+	return Context.make(SqliteClient.SqliteClient, client).pipe(Context.add(SqlClient.SqlClient, client));
+})).pipe(Layer.provide(Reactivity.layer));
 //#endregion
 export { DurableObjectSqlite_exports, layer };

package/dist/HyperdrivePg.d.mts

@@ -2,8 +2,8 @@ import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { LayerOptions, TagClass } from "./Hyperdrive.mjs";
 import * as Layer from "effect/Layer";
-import { PgClient } from "@effect/sql-pg";
 import { SqlClient, SqlError } from "effect/unstable/sql";
+import { PgClient } from "@effect/sql-pg";
 //#region src/HyperdrivePg.d.ts
 type PgLayerOptions = Omit<Parameters<typeof PgClient.makeClient>[0], "url" | "host" | "port" | "path" | "ssl" | "database" | "username" | "password" | "stream">;
 declare const layer: <Self, Id extends string>(tag: TagClass<Self, Id>, binding: LayerOptions, options?: PgLayerOptions) => Layer.Layer<PgClient.PgClient | SqlClient.SqlClient, BindingNotFoundError | BindingValidationError | SqlError.SqlError, WorkerEnvironment>;

package/dist/RpcTargets.d.mts

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+declare namespace RpcTargets_d_exports {
+  export { RpcTargetError, get, invalidate, withScope };
+}
+declare const RpcTargetError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RpcTargetError";
+} & Readonly<A>;
+/** A native RPC target could not be constructed. */
+declare class RpcTargetError extends RpcTargetError_base<{
+  readonly cause: unknown;
+}> {}
+/**
+ * Reuse a native RPC target within the current invocation. Native Durable Object
+ * stubs capture the calling request's channel when created. Recreating a stub
+ * after a callback can extend that callback's call chain until Cloudflare's
+ * subrequest depth limit is reached, even when an alarm owns the work.
+ *
+ * The owner and address must identify one target and its construction options.
+ * Outside an effect-cf invocation (or withScope), each lookup constructs a target.
+ */
+declare const get: <A extends object, Owner extends object>(owner: Owner, address: string, create: () => A) => Effect.Effect<A, RpcTargetError, never>;
+/** Discard a failed native target so a subsequent call can acquire a fresh channel. */
+declare const invalidate: <Target extends object>(target: Target) => Effect.Effect<void>;
+/**
+ * Own RPC targets in the current Scope, including a transferred response stream,
+ * never across incoming requests or durable retries. effect-cf entrypoints install this boundary automatically.
+ */
+declare const withScope: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Scope.Scope>;
+//#endregion
+export { RpcTargetError, RpcTargets_d_exports, get, invalidate, withScope };

package/dist/RpcTargets.mjs

@@ -0,0 +1,73 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+//#region src/RpcTargets.ts
+var RpcTargets_exports = /* @__PURE__ */ __exportAll({
+	RpcTargetError: () => RpcTargetError,
+	get: () => get,
+	invalidate: () => invalidate,
+	withScope: () => withScope
+});
+/** 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
+* after a callback can extend that callback's call chain until Cloudflare's
+* subrequest depth limit is reached, even when an alarm owns the work.
+*
+* The owner and address must identify one target and its construction options.
+* Outside an effect-cf invocation (or withScope), each lookup constructs a target.
+*/
+const get = (owner, address, create) => Effect.flatMap(Effect.serviceOption(CurrentTargets), (targets) => Effect.try({
+	try: () => Option.isSome(targets) ? targets.value.get(owner, address, create) : create(),
+	catch: (cause) => new RpcTargetError({ cause })
+}));
+/** Discard a failed native target so a subsequent call can acquire a fresh channel. */
+const invalidate = (target) => Effect.map(Effect.serviceOption(CurrentTargets), (targets) => {
+	if (Option.isSome(targets)) targets.value.invalidate(target);
+});
+/**
+* Own RPC targets in the current Scope, including a transferred response stream,
+* never across incoming requests or durable retries. effect-cf entrypoints install this boundary automatically.
+*/
+const withScope = (effect) => Effect.gen(function* () {
+	let active = true;
+	let owners = /* @__PURE__ */ new WeakMap();
+	let addresses = /* @__PURE__ */ new WeakMap();
+	const targets = {
+		get: (owner, address, create) => {
+			if (!active) return create();
+			let entries = owners.get(owner);
+			if (entries === void 0) {
+				entries = /* @__PURE__ */ new Map();
+				owners.set(owner, entries);
+			}
+			const existing = entries.get(address);
+			if (existing !== void 0) return existing;
+			const target = create();
+			entries.set(address, target);
+			addresses.set(target, {
+				entries,
+				address
+			});
+			return target;
+		},
+		invalidate: (target) => {
+			const entry = addresses.get(target);
+			if (entry?.entries.get(entry.address) === target) entry.entries.delete(entry.address);
+			addresses.delete(target);
+		}
+	};
+	yield* Effect.addFinalizer(() => Effect.sync(() => {
+		active = false;
+		owners = /* @__PURE__ */ new WeakMap();
+		addresses = /* @__PURE__ */ new WeakMap();
+	}));
+	return yield* effect.pipe(Effect.provideService(CurrentTargets, targets));
+});
+//#endregion
+export { RpcTargetError, RpcTargets_exports, get, invalidate, withScope };

package/dist/Worker.mjs

@@ -2,6 +2,7 @@ import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { fromExecutionContext } from "./internal/WorkerContext.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";
@@ -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

@@ -17,6 +17,7 @@ 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";
@@ -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/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.2",
+  "version": "0.41.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/DurableObjectNamespace.ts

@@ -11,6 +11,7 @@ import * as RpcDefinition from "./RpcDefinition";
 import * as ErrorMessage from "./internal/ErrorMessage";
 import * as RpcInvocation from "./internal/RpcInvocation";
 import * as RpcTracing from "./RpcTracing";
+import * as RpcTargets from "./RpcTargets";
 
 const expectedDurableObjectNamespace =
   "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
@@ -348,12 +349,18 @@ export const makeClient = <
     const get = (
       id: globalThis.DurableObjectId,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.sync(() => namespace.get(id, options));
+    ) =>
+      RpcTargets.get(namespace, JSON.stringify(["id", id.toString(), options]), () =>
+        namespace.get(id, options),
+      ).pipe(Effect.orDie);
 
     const getByName = (
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.sync(() => namespace.getByName(name, options));
+    ) =>
+      RpcTargets.get(namespace, JSON.stringify(["name", name, options]), () =>
+        namespace.getByName(name, options),
+      ).pipe(Effect.orDie);
 
     const jurisdiction = (value: globalThis.DurableObjectJurisdiction) =>
       Effect.sync(() => namespace.jurisdiction(value));
@@ -377,7 +384,7 @@ export const makeClient = <
           });
         },
         catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
-      });
+      }).pipe(Effect.tapCause(() => RpcTargets.invalidate(stub)));
 
     const rpc = Effect.fnUntraced(function* <Method extends StubMethodKey<Api>>(
       stub: StubClient,
@@ -419,7 +426,7 @@ export const makeClient = <
             method: methodName,
             cause,
           }),
-      );
+      ).pipe(Effect.tapCause(() => RpcTargets.invalidate(stub)));
     });
 
     const decodeSuccess = Effect.fnUntraced(function* <Method extends StubMethodKey<Api>>(
@@ -459,6 +466,7 @@ export const makeClient = <
       ): Effect.fn.Return<StubMethodSuccess<Api, Method>, DurableObjectRpcError> {
         const methodName = String(method);
         const value = yield* CloudflareRpc.resolve(yield* rpc(stub, method, ...args)).pipe(
+          Effect.tapCause(() => RpcTargets.invalidate(stub)),
           Effect.mapError(
             (cause) =>
               new DurableObjectRpcError({
@@ -484,6 +492,7 @@ export const makeClient = <
         const methodName = String(method);
         const result = yield* rpc(stub, method, ...args);
         const value = yield* CloudflareRpc.scoped(result).pipe(
+          Effect.tapCause(() => RpcTargets.invalidate(stub)),
           Effect.mapError(
             (cause) =>
               new DurableObjectRpcError({

package/src/DurableObjectSqlite.ts

@@ -1,7 +1,10 @@
 import { SqliteClient } from "@effect/sql-sqlite-do";
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import type { SqlClient } from "effect/unstable/sql";
+import * as Scheduler from "effect/Scheduler";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import { SqlClient } from "effect/unstable/sql";
 
 import { DurableObjectState } from "./DurableObjectState";
 
@@ -10,10 +13,22 @@ export type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db" | "s
 export const layer = (
   options?: SqliteLayerOptions,
 ): Layer.Layer<SqliteClient.SqliteClient | SqlClient.SqlClient, never, DurableObjectState> =>
-  Layer.unwrap(
+  Layer.effectContext(
     Effect.gen(function* () {
       const state = yield* DurableObjectState;
+      const client = yield* SqliteClient.make({ ...options, storage: state.raw.storage });
+      const original = client.withTransaction;
+      const scheduler = new Scheduler.MixedScheduler("sync");
+      const withTransaction: SqliteClient.SqliteClient["withTransaction"] = (body) =>
+        original(body).pipe(Effect.provideService(Scheduler.Scheduler, scheduler));
 
-      return SqliteClient.layer({ ...options, storage: state.raw.storage });
+      // Native timers retain their input gate. A blocked parent timer can prevent
+      // a transaction's later timer from running, so yield through microtasks until
+      // the native transaction settles. Keep the original client and SQL permit.
+      Object.assign(client, { withTransaction });
+
+      return Context.make(SqliteClient.SqliteClient, client).pipe(
+        Context.add(SqlClient.SqlClient, client),
+      );
     }),
-  );
+  ).pipe(Layer.provide(Reactivity.layer));

package/src/RpcTargets.ts

@@ -0,0 +1,100 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Data from "effect/Data";
+import type * as Scope from "effect/Scope";
+import * as Option from "effect/Option";
+
+/** A native RPC target could not be constructed. */
+export class RpcTargetError extends Data.TaggedError("RpcTargetError")<{
+  readonly cause: unknown;
+}> {}
+
+interface Targets {
+  get<A extends object, Owner extends object>(owner: Owner, address: string, create: () => A): A;
+  invalidate<Target extends object>(target: Target): void;
+}
+
+class CurrentTargets extends Context.Service<CurrentTargets, Targets>()("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
+ * after a callback can extend that callback's call chain until Cloudflare's
+ * subrequest depth limit is reached, even when an alarm owns the work.
+ *
+ * The owner and address must identify one target and its construction options.
+ * Outside an effect-cf invocation (or withScope), each lookup constructs a target.
+ */
+export const get = <A extends object, Owner extends object>(
+  owner: Owner,
+  address: string,
+  create: () => A,
+) =>
+  Effect.flatMap(Effect.serviceOption(CurrentTargets), (targets) =>
+    Effect.try({
+      try: () => (Option.isSome(targets) ? targets.value.get(owner, address, create) : create()),
+      catch: (cause) => new RpcTargetError({ cause }),
+    }),
+  );
+
+/** Discard a failed native target so a subsequent call can acquire a fresh channel. */
+export const invalidate = <Target extends object>(target: Target): Effect.Effect<void> =>
+  Effect.map(Effect.serviceOption(CurrentTargets), (targets) => {
+    if (Option.isSome(targets)) targets.value.invalidate(target);
+  });
+
+/**
+ * Own RPC targets in the current Scope, including a transferred response stream,
+ * never across incoming requests or durable retries. effect-cf entrypoints install this boundary automatically.
+ */
+export const withScope = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E, R | Scope.Scope> =>
+  Effect.gen(function* () {
+    let active = true;
+    let owners = new WeakMap<object, Map<string, object>>();
+    let addresses = new WeakMap<object, { entries: Map<string, object>; address: string }>();
+    const targets: Targets = {
+      get: <T extends object, Owner extends object>(
+        owner: Owner,
+        address: string,
+        create: () => T,
+      ): T => {
+        if (!active) return create();
+        let entries = owners.get(owner);
+
+        if (entries === undefined) {
+          entries = new Map();
+          owners.set(owner, entries);
+        }
+        const existing = entries.get(address);
+
+        if (existing !== undefined) {
+          // SAFETY: the caller's owner/address identifies the same native target type.
+          return existing as T;
+        }
+        const target = create();
+
+        entries.set(address, target);
+        addresses.set(target, { entries, address });
+
+        return target;
+      },
+      invalidate: (target) => {
+        const entry = addresses.get(target);
+
+        if (entry?.entries.get(entry.address) === target) entry.entries.delete(entry.address);
+        addresses.delete(target);
+      },
+    };
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        active = false;
+        owners = new WeakMap();
+        addresses = new WeakMap();
+      }),
+    );
+
+    return yield* effect.pipe(Effect.provideService(CurrentTargets, targets));
+  });

package/src/Worker.ts

@@ -13,6 +13,7 @@ import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { fromMessage, fromMessageBatch, type QueueHandler } from "./Queue";
 import * as RpcDefinition from "./RpcDefinition";
+import * as RpcTargets from "./RpcTargets";
 import type { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing";
 import * as Entrypoint from "./internal/Entrypoint";
 import * as Runtime from "./internal/Runtime";
@@ -273,11 +274,13 @@ const renderFetchSuccess = <E, R, REvent, EventLayerError, EventLayerRequirement
             });
           });
     const telemetryMiddleware = HttpMiddleware.make((self) =>
-      Effect.gen(function* () {
-        yield* Effect.addFinalizer(() => scheduleTelemetryFlush);
+      RpcTargets.withScope(
+        Effect.gen(function* () {
+          yield* Effect.addFinalizer(() => scheduleTelemetryFlush);
 
-        return yield* self;
-      }),
+          return yield* self;
+        }),
+      ),
     );
     const handled =
       eventLayer === undefined
@@ -287,24 +290,26 @@ const renderFetchSuccess = <E, R, REvent, EventLayerError, EventLayerRequirement
               httpApp,
               handleResponse,
               HttpMiddleware.make((self) =>
-                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(
-                      // The tracer schedules span completion. Let it publish on
-                      // every exit with event references still installed, before
-                      // the exporter scope finalizes.
-                      Effect.onExit(() => Effect.yieldNow),
-                      Effect.provideContext(context),
-                    );
-                  }),
-                  References.TracerEnabled,
-                  tracerEnabled,
+                RpcTargets.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(
+                        // The tracer schedules span completion. Let it publish on
+                        // every exit with event references still installed, before
+                        // the exporter scope finalizes.
+                        Effect.onExit(() => Effect.yieldNow),
+                        Effect.provideContext(context),
+                      );
+                    }),
+                    References.TracerEnabled,
+                    tracerEnabled,
+                  ),
                 ),
               ),
             ).pipe(Effect.withTracerEnabled(false)),

package/src/Workflow.ts

@@ -1,3 +1,4 @@
+import * as RpcTargets from "./RpcTargets";
 import {
   WorkflowEntrypoint as CloudflareWorkflowEntrypoint,
   type WorkflowEvent as CloudflareWorkflowEvent,
@@ -151,7 +152,11 @@ const fromWorkflowStep = (step: CloudflareWorkflowStep): WorkflowStepService =>
                   A,
                   E,
                   Exclude<R, WorkflowStepContext>
-                > = Effect.scoped(Effect.provideService(effect, WorkflowStepContext, stepContext));
+                > = Effect.scoped(
+                  RpcTargets.withScope(
+                    Effect.provideService(effect, WorkflowStepContext, stepContext),
+                  ),
+                );
 
                 return runPromise(
                   exposeCloudflareNonRetryableError(Effect.provideContext(stepEffect, context)),

package/src/index.ts

@@ -29,6 +29,7 @@ export * as R2 from "./R2";
 export * as Rpc from "./Rpc";
 export * as RpcDefinition from "./RpcDefinition";
 export * as RpcTracing from "./RpcTracing";
+export * as RpcTargets from "./RpcTargets";
 export * as ServiceBinding from "./ServiceBinding";
 export * as Vectorize from "./Vectorize";
 export * as WebTransport from "./WebTransport";

package/src/internal/Runtime.ts

@@ -5,6 +5,7 @@ import * as ManagedRuntime from "effect/ManagedRuntime";
 import type { Scope, Tracer } from "effect";
 
 import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "../Environment";
+import * as RpcTargets from "../RpcTargets";
 import { provideEntrypointServices } from "./Entrypoint";
 
 /**
@@ -61,12 +62,14 @@ export function runEventPromise<A, E, R, REvent, EventLayerError, LayerError>(
   const [runtime, effect, eventLayer, parent] = args;
 
   if (eventLayer === undefined) {
-    const event = Effect.scoped(effect);
+    const event = Effect.scoped(RpcTargets.withScope(effect));
 
     return runtime.runPromise(parent === undefined ? event : Effect.withParentSpan(event, parent));
   }
 
-  const event = Effect.scoped(effect.pipe(Effect.provide(eventLayer, { local: true })));
+  const event = Effect.scoped(
+    RpcTargets.withScope(effect.pipe(Effect.provide(eventLayer, { local: true }))),
+  );
 
   return runtime.runPromise(parent === undefined ? event : Effect.withParentSpan(event, parent));
 }