effect-cf 0.34.0 → 0.35.0

package/dist/index.mjs

@@ -2,9 +2,9 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { a as WorkerEnvironment, i as WorkerConfig, n as violationsMessage, r as Environment_exports, t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
 import { n as Service$2, r as layer$19, t as Binding_exports } from "./Binding-C82jRhdr.mjs";
 import { n as Artifacts_exports } from "./Artifacts-CBxWGeZB.mjs";
-import { a as DurableObjectWebSocket_exports, c as DurableObjectStorage_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as DurableWebSocketAttachmentError, r as fromDurableObjectState, s as fromWebSocket, t as DurableObjectState } from "./DurableObjectState-De4ZojhY.mjs";
-import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, References, Result, Schema, Tracer } from "effect";
-import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { a as DurableObjectWebSocket_exports, c as DurableObjectStorage_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as DurableWebSocketAttachmentError, r as fromDurableObjectState, s as fromWebSocket, t as DurableObjectState } from "./DurableObjectState-DcqElJ4e.mjs";
+import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, FiberSet, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, References, Result, Schema, Tracer } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpMiddleware, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
@@ -50,7 +50,7 @@ const embeddingResponse = (value) => ({
 	data: value.data ?? [],
 	[embeddingDimensionsKey]: value[embeddingDimensionsKey] ?? []
 });
-const decodeEmbeddingResponse = Schema.decodeUnknownOption(Schema.Struct({
+const decodeEmbeddingResponse = Schema.decodeUnknownEffect(Schema.Struct({
 	data: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
 	[embeddingDimensionsKey]: Schema.optional(Schema.Array(Schema.Number))
 }));
@@ -62,11 +62,14 @@ const makeClient$15 = (definition) => (ai) => {
 		definition,
 		aiGatewayLogId: tryWorkersAiSync(definition.binding, "aiGatewayLogId", () => ai.aiGatewayLogId),
 		run,
-		runEmbedding: Effect.fn("WorkersAi.runEmbedding")((model, input, options) => {
-			return run(model, input, options).pipe(Effect.map((response) => Option.match(decodeEmbeddingResponse(response), {
-				onNone: () => embeddingResponse({}),
-				onSome: embeddingResponse
+		runEmbedding: Effect.fn("WorkersAi.runEmbedding")(function* (model, input, options) {
+			const response = yield* run(model, input, options);
+			const decoded = yield* decodeEmbeddingResponse(response).pipe(Effect.mapError((cause) => new WorkersAiOperationError({
+				binding: definition.binding,
+				operation: "runEmbedding",
+				cause
 			})));
+			return embeddingResponse(decoded);
 		}),
 		models: Effect.fn("WorkersAi.models")((params) => tryWorkersAiPromise(definition.binding, "models", () => ai.models(params))),
 		gateway: (gatewayId) => tryWorkersAiSync(definition.binding, "gateway", () => ai.gateway(gatewayId)),
@@ -413,7 +416,11 @@ const queryRequest = (definition, sql, options) => {
 };
 const responseText = (definition, response, operation) => response.text.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, operation, "Failed to read Analytics Engine SQL API response body", { cause }))));
 const executeQueryRequest = (definition, httpClient, sql, options) => Effect.gen(function* () {
-	const response = yield* httpClient.execute(queryRequest(definition, sql, options)).pipe(Effect.mapError((cause) => analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", { cause })));
+	const request = yield* Effect.try({
+		try: () => queryRequest(definition, sql, options),
+		catch: (cause) => analyticsEngineQueryError(definition, "query", "Invalid Analytics Engine SQL API URL", { cause })
+	});
+	const response = yield* httpClient.execute(request).pipe(Effect.mapError((cause) => analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", { cause })));
 	if (response.status < 200 || response.status >= 300) {
 		const body = yield* responseText(definition, response, "queryErrorBody");
 		return yield* Effect.fail(analyticsEngineQueryError(definition, "query", `Analytics Engine SQL API returned HTTP ${response.status}`, {
@@ -626,9 +633,10 @@ const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 //#endregion
 //#region src/CloudflareOtlp.ts
 /**
-* Worker fetch/RPC and Durable Object alarm/RPC handlers schedule a best-effort
-* flusher. It settles within two seconds; queues and other lifecycles must
-* flush explicitly. Failures are ignored so telemetry cannot fail user events.
+* Worker fetch/queue/RPC and Durable Object alarm/RPC handlers schedule a
+* best-effort flusher. It settles within two seconds; other lifecycles must
+* flush explicitly. Scheduled flush failures cannot fail user events. Exporter
+* layer finalizers run separately and follow their configured shutdown timeout.
 */
 var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer$13,
@@ -713,6 +721,8 @@ const layerProtobuf = (options = {}) => layer$13({
 *
 * Provide this layer at runtime scope for long-lived metrics aggregation, or at
 * handler scope when traces/logs should flush as the Cloudflare event finishes.
+* A handler-scoped exporter can delay scope closure while its own finalizer
+* flushes; the two-second background flush limit does not bound layer shutdown.
 */
 const layerWorker = (options = {}) => makeLayer(options, {
 	"cloudflare.resource_type": "worker",
@@ -1474,7 +1484,13 @@ const makeClient$8 = (definition) => {
 	return (service) => {
 		const fetch = Effect.fn("ServiceBinding.fetch")(function* (input, init) {
 			return yield* Effect.tryPromise({
-				try: () => service.fetch(input, init),
+				try: (signal) => {
+					const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
+					return service.fetch(input, {
+						...init,
+						signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
+					});
+				},
 				catch: (cause) => new ServiceBindingFetchError({
 					binding: definition.binding,
 					cause
@@ -1515,7 +1531,11 @@ const makeClient$8 = (definition) => {
 		const scopedCall = Effect.fnUntraced(function* (method, ...args) {
 			const methodName = String(method);
 			const result = yield* rpc(method, ...args);
-			const value = yield* scoped(result);
+			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
 			return yield* decodeSuccess$2(methodName, value);
 		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[0])));
 		const directMethods = makeDirectMethods$1(definition.definition, call);
@@ -1674,39 +1694,42 @@ var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {
 var NativeRequest = class extends Context.Service()("effect-cf/NativeRequest") {};
 const isWebSocketUpgrade = (request) => request.headers.get("Upgrade")?.toLowerCase() === "websocket";
 const reservedMethodNames$2 = /* @__PURE__ */ new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"connect",
+	...reservedMethodNames$4,
 	"queue",
 	"scheduled",
 	"tail",
 	"tailStream",
 	"test",
-	"trace",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
+	"trace"
 ]);
 /** Override to instrument the whole event, then call super[RunSymbol]. */
 const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
 const FetchSymbol = Symbol.for("effect-cf/Worker/fetch");
-const renderFetchSuccess = (effect) => Effect.suspend(() => {
+const renderFetchSuccess = (effect, eventLayer) => Effect.suspend(() => {
 	let nativeResponse;
 	let webResponse;
-	const handled = HttpEffect.toHandled(Effect.flatMap(effect, (response) => {
+	const httpApp = Effect.flatMap(effect, (response) => {
 		if (response instanceof Response) {
 			nativeResponse = response;
 			return Effect.succeed(HttpServerResponse.empty());
 		}
 		return Effect.succeed(response);
-	}), (request, response) => nativeResponse !== void 0 ? Effect.void : Effect.map(Effect.context(), (context) => {
+	});
+	const handleResponse = (request, response) => nativeResponse !== void 0 ? Effect.void : Effect.map(Effect.context(), (context) => {
 		webResponse = HttpServerResponse.toWeb(HttpEffect.scopeTransferToStream(response), {
 			withoutBody: request.method === "HEAD",
 			context
 		});
+	});
+	const telemetryMiddleware = HttpMiddleware.make((self) => Effect.gen(function* () {
+		yield* Effect.addFinalizer(() => scheduleTelemetryFlush$1);
+		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 context = yield* Layer.build(Layer.fresh(eventLayer));
+		yield* Effect.addFinalizer(() => Effect.provideContext(scheduleTelemetryFlush$1, context));
+		return yield* HttpMiddleware.tracer(self).pipe(Effect.onExit(() => Effect.yieldNow), Effect.provideContext(context));
+	}), References.TracerEnabled, tracerEnabled))).pipe(Effect.withTracerEnabled(false)));
 	const captured = () => nativeResponse ?? webResponse ?? new Response(null, { status: 500 });
 	return Effect.matchCause(handled, {
 		onFailure: captured,
@@ -1715,13 +1738,13 @@ const renderFetchSuccess = (effect) => Effect.suspend(() => {
 });
 const isWorkerOptions = (options) => !Effect.isEffect(options);
 /**
-* Drains buffered OTLP telemetry once the fetch handler has produced its
-* response.
+* Drains buffered OTLP telemetry when the fetch Effect scope closes. Effect
+* response streams transfer that scope to the body and schedule the flush when
+* the body finishes or is canceled.
 *
-* The flush is handed to `ctx.waitUntil` so it never delays the response
-* (including streaming bodies still being consumed). It is a no-op when the
-* context does not contain an `OtlpExporter.Flusher`. The handed-off effect is
-* best-effort and silently settles within two seconds.
+* The flush is handed to `ctx.waitUntil` instead of being awaited by the
+* handler. It is a no-op when the context does not contain an
+* `OtlpExporter.Flusher`, and silently settles within two seconds.
 */
 const scheduleTelemetryFlush$1 = scheduleTelemetryFlush$2((flush) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)));
 function make$9(layer, optionsOrFetch) {
@@ -1733,7 +1756,7 @@ function make$9(layer, optionsOrFetch) {
 			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
 		}
 		[RunSymbol$1](effect, runOptions = {}) {
-			const eventLayer = options.eventLayer;
+			const eventLayer = runOptions.event === "fetch" ? void 0 : options.eventLayer;
 			const parent = runOptions.rpc?.parent;
 			const parentSpan = parent === void 0 ? void 0 : Tracer.externalSpan(parent);
 			if (eventLayer === void 0) return runEventPromise(this.runtime, effect, void 0, parentSpan);
@@ -1747,13 +1770,13 @@ function make$9(layer, optionsOrFetch) {
 			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
 			const ctx = requestContext ?? this.ctx;
 			const requestServices = Layer.mergeAll(Layer.succeed(NativeRequest, request), Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)), Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx)));
-			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.tap(() => scheduleTelemetryFlush$1), Effect.provide(requestServices)), { event: "fetch" });
+			return this[RunSymbol$1](renderFetchSuccess(fetchHandler, options.eventLayer).pipe(Effect.provide(requestServices)), { event: "fetch" });
 		}
 		queue(batch) {
 			const queueHandler = options.queue;
 			if (queueHandler === void 0) return Promise.resolve();
 			const messages = batch.messages.map((message) => fromMessage(message, message.body));
-			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)), { event: "queue" });
+			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)).pipe(Effect.onExit(() => scheduleTelemetryFlush$1)), { event: "queue" });
 		}
 	}
 	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect, rpc) => self[RunSymbol$1](effect, {
@@ -1812,7 +1835,13 @@ const makeClient$7 = (definition) => {
 		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
 		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
 		const fetch = (stub, input, init) => Effect.tryPromise({
-			try: () => stub.fetch(input, init),
+			try: (signal) => {
+				const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
+				return stub.fetch(input, {
+					...init,
+					signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
+				});
+			},
 			catch: (cause) => new DurableObjectFetchError({
 				binding: definition.binding,
 				cause
@@ -1852,7 +1881,11 @@ const makeClient$7 = (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);
+			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+				binding: definition.binding,
+				method: methodName,
+				cause
+			})));
 			return yield* decodeSuccess$1(methodName, value);
 		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[1])));
 		const directMethods = makeDirectMethods(definition.definition, {
@@ -2023,18 +2056,16 @@ var DurableObject_exports = /* @__PURE__ */ __exportAll({
 	make: () => make$7,
 	method: () => method
 });
-const reservedMethodNames = /* @__PURE__ */ new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
-]);
+const reservedMethodNames = reservedMethodNames$4;
 /** Override to instrument the whole event, then call super[RunSymbol]. */
 const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 const scheduleTelemetryFlush = scheduleTelemetryFlush$2((flush) => Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)));
+/**
+* Builds a Durable Object whose base `layer` lives for the in-memory instance.
+* Cloudflare does not expose an eviction or shutdown hook, so finalizers in
+* that layer are not guaranteed to run. Put resources that require timely
+* release in `eventLayer`, whose scope closes after each handled event.
+*/
 const make$7 = (layer, options = {}) => {
 	class EffectDurableObject extends DurableObject {
 		runtime;
@@ -2411,7 +2442,6 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 	const disconnects = yield* Queue.make();
 	const connectionsBySocket = /* @__PURE__ */ new Map();
 	const connectionsById = /* @__PURE__ */ new Map();
-	const clientIds = /* @__PURE__ */ new Set();
 	const resetSockets = /* @__PURE__ */ new WeakSet();
 	const declarationsById = /* @__PURE__ */ new Map();
 	const declarationsByTag = /* @__PURE__ */ new Map();
@@ -2427,14 +2457,6 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		declarationsByTag.set(declaration.rpcTag, declaration);
 	}
 	const reserveClientId = (socket) => {
-		const attachment = readAttachment(socket.raw, attachmentKey);
-		if (attachment._tag === "Invalid") throw new Error("Invalid Durable Object RPC websocket attachment metadata");
-		if (attachment._tag === "Valid") {
-			const metadata = attachment.metadata;
-			nextClientId = Math.max(nextClientId, metadata.clientId + 1);
-			writeAttachment(socket.raw, attachmentKey, metadata);
-			return metadata;
-		}
 		const id = nextClientId++;
 		const created = {
 			version: legacyAttachmentVersion,
@@ -2487,7 +2509,6 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		for (const subscription of restoredSubscriptions) if (!addSubscription(connection, subscription)) throw new Error("Duplicate restored resumable RPC stream subscription identity");
 		connectionsBySocket.set(socket.raw, connection);
 		connectionsById.set(connection.id, connection);
-		clientIds.add(connection.id);
 		nextClientId = Math.max(nextClientId, connection.id + 1);
 		return connection;
 	};
@@ -2524,7 +2545,6 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 		if (connection === void 0) return;
 		connectionsBySocket.delete(socket.raw);
 		connectionsById.delete(connection.id);
-		clientIds.delete(connection.id);
 		activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
 		connection.requestIds.clear();
 		connection.nonResumableRequestIds.clear();
@@ -2743,7 +2763,7 @@ const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
 			end: (clientId) => Effect.sync(() => {
 				connectionsById.get(clientId)?.socket.raw.close();
 			}),
-			clientIds: Effect.sync(() => clientIds),
+			clientIds: Effect.sync(() => new Set(connectionsById.keys())),
 			initialMessage: Effect.succeedNone,
 			supportsAck: true,
 			supportsTransferables: false,
@@ -2877,13 +2897,9 @@ const writeAttachment = (socket, key, metadata) => {
 	const current = socket.deserializeAttachment();
 	if (current !== null && current !== void 0 && !Predicate.isObject(current)) throw new Error("DurableObjectRpcWebSocket requires object-shaped websocket attachments so adapter metadata can preserve application fields");
 	const attachment = Predicate.isObject(current) ? current : {};
-	const currentMetadata = Predicate.hasProperty(attachment, key) && Predicate.isObject(attachment[key]) ? attachment[key] : {};
 	socket.serializeAttachment({
 		...attachment,
-		[key]: {
-			...currentMetadata,
-			...metadata
-		}
+		[key]: metadata
 	});
 };
 const makeHeartbeatController = (state, serialization, policy) => Effect.gen(function* () {
@@ -3835,20 +3851,29 @@ const exposeCloudflareNonRetryableError = (effect) => Effect.catchCause(effect,
 	const error = Cause.findErrorOption(cause);
 	return Option.isSome(error) && error.value instanceof WorkflowStepNonRetryableError ? Effect.die(toCloudflareNonRetryableError(error.value)) : Effect.failCause(cause);
 });
-const fromWorkflowStep = (step, runPromise) => ({
+const fromWorkflowStep = (step) => ({
 	raw: step,
-	do: (name, effect, config) => Effect.context().pipe(Effect.flatMap((context) => Effect.tryPromise({
-		try: () => {
-			const run = (stepContext) => runPromise(exposeCloudflareNonRetryableError(Effect.scoped(Effect.provideService(Effect.provideContext(effect, context), WorkflowStepContext$1, stepContext))));
-			const rawStep = step;
-			return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
-		},
-		catch: (cause) => new WorkflowStepError({
-			step: name,
-			operation: "do",
-			cause
-		})
-	}))),
+	do: (name, effect, config) => Effect.gen(function* () {
+		const context = yield* Effect.context();
+		return yield* Effect.scoped(Effect.gen(function* () {
+			const runPromise = yield* FiberSet.makeRuntimePromise();
+			return yield* Effect.tryPromise({
+				try: () => {
+					const run = (stepContext) => {
+						const stepEffect = Effect.scoped(Effect.provideService(effect, WorkflowStepContext$1, stepContext));
+						return runPromise(exposeCloudflareNonRetryableError(Effect.provideContext(stepEffect, context)));
+					};
+					const rawStep = step;
+					return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
+				},
+				catch: (cause) => new WorkflowStepError({
+					step: name,
+					operation: "do",
+					cause
+				})
+			});
+		}));
+	}),
 	sleep: (name, duration) => Effect.tryPromise({
 		try: () => step.sleep(name, duration),
 		catch: (cause) => new WorkflowStepError({
@@ -3884,7 +3909,7 @@ const make = (layer, options) => {
 			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
 		}
 		run(event, step) {
-			const workflowServices = Layer.mergeAll(Layer.succeed(WorkflowEvent$1, fromWorkflowEvent(event)), Layer.succeed(WorkflowStep$1, fromWorkflowStep(step, (effect) => this.runtime.runPromise(effect))));
+			const workflowServices = Layer.mergeAll(Layer.succeed(WorkflowEvent$1, fromWorkflowEvent(event)), Layer.succeed(WorkflowStep$1, fromWorkflowStep(step)));
 			return runEventPromise(this.runtime, options.run(event.payload), workflowServices);
 		}
 	}

package/package.json

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

package/src/AnalyticsEngine.ts

@@ -572,7 +572,14 @@ const executeQueryRequest = (
   options?: AnalyticsEngineQueryOptions,
 ) =>
   Effect.gen(function* () {
-    const response = yield* httpClient.execute(queryRequest(definition, sql, options)).pipe(
+    const request = yield* Effect.try({
+      try: () => queryRequest(definition, sql, options),
+      catch: (cause) =>
+        analyticsEngineQueryError(definition, "query", "Invalid Analytics Engine SQL API URL", {
+          cause,
+        }),
+    });
+    const response = yield* httpClient.execute(request).pipe(
       Effect.mapError((cause) =>
         analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", {
           cause,

package/src/CloudflareOtlp.ts

@@ -1,7 +1,8 @@
 /**
- * Worker fetch/RPC and Durable Object alarm/RPC handlers schedule a best-effort
- * flusher. It settles within two seconds; queues and other lifecycles must
- * flush explicitly. Failures are ignored so telemetry cannot fail user events.
+ * Worker fetch/queue/RPC and Durable Object alarm/RPC handlers schedule a
+ * best-effort flusher. It settles within two seconds; other lifecycles must
+ * flush explicitly. Scheduled flush failures cannot fail user events. Exporter
+ * layer finalizers run separately and follow their configured shutdown timeout.
  */
 import { ConfigProvider, Effect, Layer, Option } from "effect";
 import type * as Tracer from "effect/Tracer";
@@ -207,6 +208,8 @@ export const layerProtobuf = (
  *
  * Provide this layer at runtime scope for long-lived metrics aggregation, or at
  * handler scope when traces/logs should flush as the Cloudflare event finishes.
+ * A handler-scoped exporter can delay scope closure while its own finalizer
+ * flushes; the two-second background flush limit does not bound layer shutdown.
  */
 export const layerWorker = (options: WorkerLayerOptions = {}): Layer.Layer<OtlpExporter.Flusher> =>
   makeLayer(options, {

package/src/ComputerWorkspace.ts

@@ -100,6 +100,17 @@ export class WorkspaceAssetsError extends Schema.TaggedError<WorkspaceAssetsErro
   },
 ) {}
 
+/** Schema-serializable error while acquiring the Computer workspace client. */
+export class WorkspaceAcquireError extends Schema.TaggedError<WorkspaceAcquireError>()(
+  "WorkspaceAcquireError",
+  {
+    operation: Schema.String,
+    message: Schema.String,
+    code: Schema.optionalKey(Schema.String),
+    cause: Schema.optionalKey(Schema.Defect({ includeStack: true })),
+  },
+) {}
+
 export type WorkspaceReadFileOptions = Omit<CloudflareReadFileOptions, "encoding">;
 export type ReadTextFileOptions = WorkspaceReadFileOptions;
 export type ListDirectoryOptions = CloudflareReaddirOptions;
@@ -469,6 +480,21 @@ const execError = (operation: string, cause: unknown) => {
   return WorkspaceExecError.make(properties);
 };
 
+const acquireError = (operation: string, cause: unknown) => {
+  const properties: WorkspaceOperationErrorProperties = {
+    operation,
+    message: errorMessage(cause),
+    cause,
+  };
+  const code = errorCode(cause);
+
+  if (code !== undefined) {
+    properties.code = code;
+  }
+
+  return WorkspaceAcquireError.make(properties);
+};
+
 const assetsError = (operation: string, path: string, cause: unknown) => {
   const properties: WorkspaceFsErrorProperties = {
     operation,
@@ -887,9 +913,6 @@ const wrapRun = <Encoding extends WorkspaceExecEncoding>(
   return { id: handle.id, backend: handle.backend, events, result, kill };
 };
 
-const releaseRun = (handle: CloudflareWorkspaceRuntimeExecHandle<"utf8" | undefined>) =>
-  Effect.sync(() => handle[Symbol.dispose]());
-
 const makeRuntime = (client: CloudflareWorkspaceClient): ComputerWorkspaceRuntime => {
   const execImplementation = Effect.fn("ComputerWorkspace.runtime.exec", {
     attributes: { family: "runtime", operation: "exec" },
@@ -905,7 +928,7 @@ const makeRuntime = (client: CloudflareWorkspaceClient): ComputerWorkspaceRuntim
       : undefined;
 
     yield* Effect.annotateCurrentSpan({ backend: options?.backend, runId: options?.id });
-    const handle = yield* Effect.acquireRelease(
+    const handle = yield* Effect.acquireDisposable(
       Effect.tryPromise({
         try: () => {
           if (Predicate.isString(source)) {
@@ -926,7 +949,6 @@ const makeRuntime = (client: CloudflareWorkspaceClient): ComputerWorkspaceRuntim
         },
         catch: (cause) => execError("exec", cause),
       }),
-      releaseRun,
     );
 
     // SAFETY: runtimeExecOptions carries Encoding to Cloudflare's corresponding handle overload.
@@ -945,12 +967,11 @@ const makeRuntime = (client: CloudflareWorkspaceClient): ComputerWorkspaceRuntim
     options?: WorkspaceGetExecOptions<Encoding>,
   ) {
     yield* Effect.annotateCurrentSpan({ backend: options?.backend, runId: id });
-    const handle = yield* Effect.acquireRelease(
+    const handle = yield* Effect.acquireDisposable(
       Effect.tryPromise({
         try: () => client.runtime.getExec(id, runtimeGetOptions(options)),
         catch: (cause) => execError("getExec", cause),
       }),
-      releaseRun,
     );
 
     // SAFETY: runtimeGetOptions carries Encoding to Cloudflare's corresponding handle overload.
@@ -1169,25 +1190,31 @@ export class ComputerWorkspace extends Context.Service<
    * Acquires the single workspace registered by `withComputerWorkspace` and
    * releases its RPC client when the layer scope closes.
    */
-  static readonly layer: Layer.Layer<ComputerWorkspace, never, DurableObjectState> = Layer.effect(
-    ComputerWorkspace,
-    Effect.gen(function* () {
-      const state = yield* DurableObjectState;
-      const host = HostRegistry.lookup(state.raw);
-
-      if (host === undefined) {
-        return yield* Effect.die(
-          "ComputerWorkspace.layer requires a Durable Object class built with withComputerWorkspace",
+  static readonly layer: Layer.Layer<ComputerWorkspace, WorkspaceAcquireError, DurableObjectState> =
+    Layer.effect(
+      ComputerWorkspace,
+      Effect.gen(function* () {
+        const state = yield* DurableObjectState;
+        const host = HostRegistry.lookup(state.raw);
+
+        if (host === undefined) {
+          return yield* Effect.die(
+            "ComputerWorkspace.layer requires a Durable Object class built with withComputerWorkspace",
+          );
+        }
+
+        const computer = yield* Effect.tryPromise({
+          try: () => import("@cloudflare/computer"),
+          catch: (cause) => acquireError("import", cause),
+        });
+        const client = yield* Effect.acquireDisposable(
+          Effect.tryPromise({
+            try: () => computer.getWorkspace(host),
+            catch: (cause) => acquireError("getWorkspace", cause),
+          }),
         );
-      }
-
-      const computer = yield* Effect.promise(() => import("@cloudflare/computer"));
-      const client = yield* Effect.acquireRelease(
-        Effect.promise(() => computer.getWorkspace(host)),
-        (workspace) => Effect.sync(() => workspace[Symbol.dispose]()),
-      );
 
-      return ComputerWorkspace.of(fromWorkspaceClient(client));
-    }),
-  );
+        return ComputerWorkspace.of(fromWorkspaceClient(client));
+      }),
+    );
 }

package/src/DurableObject.ts

@@ -5,20 +5,13 @@ import { NativeRequest } from "./Worker";
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState";
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";
+import * as RpcDefinition from "./RpcDefinition";
 import * as Entrypoint from "./internal/Entrypoint";
 import * as Runtime from "./internal/Runtime";
 import * as Telemetry from "./internal/Telemetry";
 import type { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing";
 
-const reservedMethodNames = new Set<string>([
-  "constructor",
-  "dup",
-  "fetch",
-  "alarm",
-  "webSocketMessage",
-  "webSocketClose",
-  "webSocketError",
-]);
+const reservedMethodNames: ReadonlySet<string> = RpcDefinition.reservedMethodNames;
 
 type RuntimeContext<ROut> = DurableObjectState | WorkerEnvironment | ROut;
 
@@ -167,6 +160,12 @@ export type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (
     ): Promise<A>;
   };
 
+/**
+ * Builds a Durable Object whose base `layer` lives for the in-memory instance.
+ * Cloudflare does not expose an eviction or shutdown hook, so finalizers in
+ * that layer are not guaranteed to run. Put resources that require timely
+ * release in `eventLayer`, whose scope closes after each handled event.
+ */
 export const make = <
   ROut,
   LayerError,

package/src/DurableObjectNamespace.ts

@@ -250,7 +250,7 @@ export type DurableObjectNamespaceEffectClient<
     stub: DurableObjectStubClient<Api>,
     method: Method,
     ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope>;
   /**
    * Exposes the underlying native Durable Object namespace binding.
    *
@@ -300,7 +300,11 @@ export type DurableObjectNamespaceStaticClient<
     stub: DurableObjectStubClient<Api>,
     method: Method,
     ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
+  ) => Effect.Effect<
+    Awaited<StubMethodSuccess<Api, Method>>,
+    DurableObjectRpcError,
+    Scope.Scope | R
+  >;
   readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 
@@ -351,7 +355,22 @@ export const makeClient = <
 
     const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
       Effect.tryPromise({
-        try: () => stub.fetch(input, init),
+        try: (signal) => {
+          const callerSignal =
+            init?.signal !== undefined
+              ? init.signal
+              : input instanceof Request
+                ? input.signal
+                : undefined;
+
+          return stub.fetch(input, {
+            ...init,
+            signal:
+              callerSignal === null || callerSignal === undefined
+                ? signal
+                : AbortSignal.any([callerSignal, signal]),
+          });
+        },
         catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
       });
 
@@ -456,10 +475,19 @@ export const makeClient = <
         stub: StubClient,
         method: Method,
         ...args: StubMethodArgs<Api, Method>
-      ): Effect.fn.Return<StubMethodSuccess<Api, Method>, unknown, Scope.Scope> {
+      ): Effect.fn.Return<StubMethodSuccess<Api, Method>, DurableObjectRpcError, Scope.Scope> {
         const methodName = String(method);
         const result = yield* rpc(stub, method, ...args);
-        const value = yield* CloudflareRpc.scoped(result);
+        const value = yield* CloudflareRpc.scoped(result).pipe(
+          Effect.mapError(
+            (cause) =>
+              new DurableObjectRpcError({
+                binding: definition.binding,
+                method: methodName,
+                cause,
+              }),
+          ),
+        );
 
         return yield* decodeSuccess<Method>(methodName, value);
       },