effect-cf 0.28.0 → 0.29.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # effect-cf
 
+## 0.29.0
+
+### Minor Changes
+
+- [#108](https://github.com/danieljvdm/effect-cf/pull/108) [`735b6d9`](https://github.com/danieljvdm/effect-cf/commit/735b6d95e4b62c7ade598a7f18ba2d8b4ee60f87) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Require the Effect 4.0.0-rc.110 family — dependency ranges move from `^4.0.0-beta.107 <4.0.0-rc.0` to `^4.0.0-rc.110`.
+
+### Patch Changes
+
+- [#66](https://github.com/danieljvdm/effect-cf/pull/66) [`fe34f95`](https://github.com/danieljvdm/effect-cf/commit/fe34f95abc92f4637968186aeebbb8033157c041) Thanks [@danieljvdm](https://github.com/danieljvdm)! - `DurableObjectStorage.transaction` and `transactionSync` now recover the aborting `Exit` by identity instead of re-deriving its type from the untyped `catch` binding. Failures raised inside a transaction keep the same typed error channel, and a failure thrown by the platform itself is still reported as `StorageOperationError`. No public API change.
+
+## 0.28.1
+
+### Patch Changes
+
+- [#105](https://github.com/danieljvdm/effect-cf/pull/105) [`f5dfd5e`](https://github.com/danieljvdm/effect-cf/commit/f5dfd5e2c79b257cc760dc0b2cdf5a2901b0b295) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Bound internally scheduled telemetry flushes so exporter retries cannot extend Worker or Durable Object event lifetimes indefinitely.
+
+- [#106](https://github.com/danieljvdm/effect-cf/pull/106) [`c0fbb85`](https://github.com/danieljvdm/effect-cf/commit/c0fbb8535479262741e6844935e9ff9d508f6b56) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Silently absorb failures raised while scheduling automatic OTLP telemetry flushes so platform boundary defects cannot feed back into the configured exporter. Document the two-second best-effort boundary and keep explicit queue flush policy application-owned.
+
 ## 0.28.0
 
 ### Minor Changes

package/README.md

@@ -357,6 +357,12 @@ Producers should usually use `const queue = yield* AvatarQueue` and then call `q
 
 Queue handlers run inline failures through Cloudflare's normal retry path. If background work scheduled with `WorkerContext.waitUntil(...)` should also make the batch retry, use `WorkerContext.waitUntilPropagating(...)` or `waitUntil(..., { mode: "propagate" })`; the default `waitUntil` mode observes and logs failures without rejecting the native `waitUntil` promise.
 
+effect-cf automatically schedules best-effort OTLP flushes only for Worker
+fetch/RPC and Durable Object alarm/RPC handlers. Those internal flushes are
+capped at two seconds. Queue handlers do not flush telemetry automatically;
+applications that explicitly flush in a queue handler own that flush's timeout
+and failure policy.
+
 ## Cache Example
 
 `Cache.layer` exposes Cloudflare's global Cache API as an Effect service. Cache misses are represented by `Option.none()`, and named caches are available through `open(...)`.

package/dist/ComputerWorkspace.d.mts

@@ -1,5 +1,5 @@
 import { ComputerArtifactsClient } from "./ComputerArtifacts.mjs";
-import { t as DurableObjectState } from "./DurableObjectState-B3uFY1eM.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-OupNMMUl.mjs";
 import { Context, Effect, Layer, Schema, Scope, Stream } from "effect";
 import { CommitView, GitClient, GitCloneOptions, GitCommitOptions, GitDiffOptions, GitFetchOptions, GitLogOptions, GitUpdateRefOptions } from "@cloudflare/computer/git";
 import { ExecSyncResult, RuntimeExecOptions, RuntimeGetOptions, RuntimeKillOptions, ShellValue, SkippedEntry, ThinkWorkspaceCompatibility, WorkspaceClient, WorkspaceRuntimeResult, WorkspaceRuntimeValue as WorkspaceRuntimeValue$1 } from "@cloudflare/computer";

package/dist/ComputerWorkspace.mjs

@@ -1,4 +1,4 @@
-import { t as DurableObjectState } from "./DurableObjectState-BjkK2kwH.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-DnnLoHV-.mjs";
 import { fromClient } from "./ComputerArtifacts.mjs";
 import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
 import { Context, Effect, Layer, Predicate, Schema, Stream } from "effect";

package/dist/{DurableObjectState-BjkK2kwH.mjs → DurableObjectState-DnnLoHV-.mjs}

@@ -99,24 +99,28 @@ const fromDurableObjectStorage = (storage) => ({
 	setAlarm: (scheduledTime, options) => tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
 	deleteAlarm: (options) => tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
 	transactionSync: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.suspend(() => {
+		let aborted;
 		try {
 			return Effect.succeed(storage.transactionSync(() => {
 				const exit = Effect.runSyncExitWith(context)(closure());
 				if (Exit.isSuccess(exit)) return exit.value;
+				aborted = exit;
 				throw exit;
 			}));
 		} catch (cause) {
-			if (Exit.isExit(cause) && Exit.isFailure(cause)) return Effect.failCause(cause.cause);
+			if (aborted !== void 0 && cause === aborted && Exit.isFailure(aborted)) return Effect.failCause(aborted.cause);
 			return Effect.fail(storageError("transactionSync", cause));
 		}
 	}))),
 	transaction: (closure) => Effect.context().pipe(Effect.flatMap((context) => Effect.callback((resume) => {
+		let aborted;
 		storage.transaction(async (txn) => {
 			const exit = await Effect.runPromiseExitWith(context)(closure(fromDurableObjectTransaction(txn)));
 			if (Exit.isSuccess(exit)) return exit.value;
+			aborted = exit;
 			throw exit;
 		}).then((value) => resume(Effect.succeed(value)), (cause) => {
-			if (Exit.isExit(cause) && Exit.isFailure(cause)) resume(Effect.failCause(cause.cause));
+			if (aborted !== void 0 && cause === aborted && Exit.isFailure(aborted)) resume(Effect.failCause(aborted.cause));
 			else resume(Effect.fail(storageError("transaction", cause)));
 		});
 	}))),

package/dist/{DurableObjectState-B3uFY1eM.d.mts → DurableObjectState-OupNMMUl.d.mts}

@@ -888,7 +888,8 @@ interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc e
    *
    * The layer is built inside the event's Effect scope and finalized when the
    * event effect completes. Use this for event-scoped resources such as OTLP
-   * trace/log exporters that should flush at event completion.
+   * trace/log exporters. Worker fetch and RPC handlers schedule a best-effort
+   * flush capped at two seconds; queue handlers do not flush automatically.
    */
   readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
   /** Main request handler. */
@@ -899,7 +900,8 @@ interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc e
    * Optional RPC methods exposed as class instance methods.
    *
    * After every invocation, the configured OTLP flusher is scheduled through
-   * `WorkerContext.waitUntil`, including when the handler fails.
+   * `WorkerContext.waitUntil`, including when the handler fails. The scheduled
+   * flush silently settles within two seconds even if the exporter does not.
    */
   readonly rpc?: Rpc;
 }

package/dist/Vitest.d.mts

@@ -1,6 +1,6 @@
 import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-xJJJPmiD.mjs";
-import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-B3uFY1eM.mjs";
-import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-wZ-yGHow.mjs";
+import { n as DurableObjectStateService, t as DurableObjectState } from "./DurableObjectState-OupNMMUl.mjs";
+import { o as WorkflowInstanceStatusName } from "./WorkflowBinding-DUZtKCVM.mjs";
 import { Effect, Layer, Schema } from "effect";
 import { DurableObject } from "cloudflare:workers";
 import { adminSecretsStore as adminSecretsStore$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1 } from "cloudflare:test";

package/dist/Vitest.mjs

@@ -1,5 +1,5 @@
 import { a as WorkerEnvironment, i as WorkerConfig } from "./ErrorMessage-BM0K-Nik.mjs";
-import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-BjkK2kwH.mjs";
+import { r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-DnnLoHV-.mjs";
 import { ConfigProvider, Effect, Exit, Layer } from "effect";
 import { env } from "cloudflare:workers";
 import { abortAllDurableObjects as abortAllDurableObjects$1, adminSecretsStore as adminSecretsStore$1, applyD1Migrations as applyD1Migrations$1, createExecutionContext, createMessageBatch, createPagesEventContext, createScheduledController, evictAllDurableObjects as evictAllDurableObjects$1, evictDurableObject as evictDurableObject$1, getQueueResult, introspectWorkflow as introspectWorkflow$1, introspectWorkflowInstance as introspectWorkflowInstance$1, listDurableObjectIds as listDurableObjectIds$1, reset as reset$1, runDurableObjectAlarm as runDurableObjectAlarm$1, runInDurableObject as runInDurableObject$1, waitOnExecutionContext } from "cloudflare:test";

package/dist/{WorkflowBinding-wZ-yGHow.d.mts → WorkflowBinding-DUZtKCVM.d.mts}

@@ -1,5 +1,5 @@
 import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
-import { x as ServiceFreeSchema } from "./DurableObjectState-B3uFY1eM.mjs";
+import { x as ServiceFreeSchema } from "./DurableObjectState-OupNMMUl.mjs";
 import { Context, Effect, Option, Schema } from "effect";
 declare namespace WorkflowBinding_d_exports {
   export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import { a as Environment_d_exports, c as WorkerEnvironment, i as Binding_d_exports, n as BindingService, o as WorkerConfig, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-xJJJPmiD.mjs";
 import { l as Artifacts_d_exports } from "./Artifacts-DnHQA-Ax.mjs";
-import { C as Rpc_d_exports, D as StorageOperationError, E as DurableObjectStorage_d_exports, S as Provider, T as DurableWebSocket, _ as Definition$4, a as NativeRequest, b as RpcDefinition_d_exports, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as QueueBinding_d_exports, h as QueueDefinition_d_exports, i as ExecutionContext, l as ServiceBinding_d_exports, m as Queue_d_exports, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as Method$2, w as DurableObjectWebSocket_d_exports, x as ServiceFreeSchema$1, y as ReservedMethodName$2 } from "./DurableObjectState-B3uFY1eM.mjs";
+import { C as Rpc_d_exports, D as StorageOperationError, E as DurableObjectStorage_d_exports, S as Provider, T as DurableWebSocket, _ as Definition$4, a as NativeRequest, b as RpcDefinition_d_exports, c as WorkerDefinition_d_exports, d as AsyncMethodCloudflareReturn, f as AsyncMethodKey, g as QueueBinding_d_exports, h as QueueDefinition_d_exports, i as ExecutionContext, l as ServiceBinding_d_exports, m as Queue_d_exports, o as WorkerContext, p as AsyncMethodSuccess, r as DurableObjectState_d_exports, s as Worker_d_exports, t as DurableObjectState, u as AsyncMethodArgs, v as Method$2, w as DurableObjectWebSocket_d_exports, x as ServiceFreeSchema$1, y as ReservedMethodName$2 } from "./DurableObjectState-OupNMMUl.mjs";
 import { t as Hyperdrive_d_exports } from "./Hyperdrive-z-9fFz15.mjs";
-import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-wZ-yGHow.mjs";
+import { a as WorkflowInstanceCreateOptions, i as WorkflowInstanceCreateBatchOptions, n as WorkflowBinding_d_exports, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient } from "./WorkflowBinding-DUZtKCVM.mjs";
 import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Predicate, Redacted, Schema, Scope } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpResource } from "effect/unstable/observability";
@@ -1111,7 +1111,9 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * Optional RPC methods exposed as Durable Object instance methods.
    *
    * After every invocation, the configured OTLP flusher is scheduled through
-   * `DurableObjectState.waitUntil`, including when the handler fails.
+   * `DurableObjectState.waitUntil`, including when the handler fails. The
+   * scheduled flush silently settles within two seconds even if the exporter
+   * does not.
    */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
@@ -1128,7 +1130,9 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * Optional raw alarm handler.
    *
    * After every invocation, the configured OTLP flusher is scheduled through
-   * `DurableObjectState.waitUntil`, including when the handler fails.
+   * `DurableObjectState.waitUntil`, including when the handler fails. The
+   * scheduled flush silently settles within two seconds even if the exporter
+   * does not.
    */
   readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
   readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;

package/dist/index.mjs

@@ -1,7 +1,7 @@
 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-BM0K-Nik.mjs";
 import { a as layer$19, i as Service$2, n as Artifacts_exports, r as Binding_exports } from "./Artifacts-rq3hUKQE.mjs";
-import { a as DurableObjectWebSocket_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState } from "./DurableObjectState-BjkK2kwH.mjs";
+import { a as DurableObjectWebSocket_exports, i as fromExecutionContext, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState } from "./DurableObjectState-DnnLoHV-.mjs";
 import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
@@ -643,16 +643,23 @@ const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 * telemetry on demand. Cloudflare isolates can freeze before the periodic
 * export interval fires. Effect-backed Worker fetch handlers, Worker or
 * Durable Object native RPC handlers, and Durable Object alarm handlers
-* schedule this flusher automatically.
-* Flush or scheduling failures do not replace the handler outcome and emit
-* only bounded framework diagnostics without attaching the foreign cause.
-* Other entrypoint lifecycles can flush explicitly or hand the flush to their
-* `waitUntil` mechanism:
+* schedule this flusher automatically. These automatic flushes are capped at
+* two seconds and silently discard timeouts and failures so telemetry cannot
+* extend or fail the user event, or recursively log through an unhealthy
+* exporter.
+*
+* Other entrypoint lifecycles, including queue handlers, do not flush
+* automatically. Applications can flush explicitly or hand the flush to their
+* `waitUntil` mechanism, and own the timeout and failure policy at that call
+* site:
 *
 * ```ts
 * const flusher = yield* OtlpExporter.Flusher;
 *
-* yield* flusher.flush;
+* yield* flusher.flush.pipe(
+*   Effect.timeoutOption("2 seconds"),
+*   Effect.ignoreCause,
+* );
 * ```
 */
 var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
@@ -1342,16 +1349,20 @@ function runEventPromise(...args) {
 }
 //#endregion
 //#region src/internal/Telemetry.ts
-const logFlushFailure = Effect.logError("Telemetry flush failed").pipe(Effect.ignoreCause);
-const logFlushSchedulingFailure = Effect.logError("Telemetry flush scheduling failed").pipe(Effect.ignoreCause);
+/** Maximum event lifetime spent on an internally scheduled telemetry flush. */
+const scheduledFlushTimeout = "2 seconds";
 /**
 * Schedules a configured OTLP flusher through the current Cloudflare event.
+*
+* The handed-off effect is best-effort: it settles within two seconds and
+* silently absorbs every failure cause so telemetry cannot extend or fail the
+* user event, or recursively log through an unhealthy exporter.
 */
 const scheduleTelemetryFlush$2 = (waitUntil) => Effect.gen(function* () {
 	const flusher = yield* Effect.serviceOption(OtlpExporter.Flusher);
 	if (Option.isNone(flusher)) return;
-	yield* waitUntil(flusher.value.flush.pipe(Effect.catchCause(() => logFlushFailure)));
-}).pipe(Effect.catchCause(() => logFlushSchedulingFailure));
+	yield* waitUntil(flusher.value.flush.pipe(Effect.timeoutOption(scheduledFlushTimeout), Effect.ignoreCause, Effect.asVoid));
+}).pipe(Effect.ignoreCause);
 //#endregion
 //#region src/Rpc.ts
 var Rpc_exports = /* @__PURE__ */ __exportAll({
@@ -1737,7 +1748,8 @@ const isWorkerOptions = (options) => !Effect.isEffect(options);
 *
 * 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`.
+* context does not contain an `OtlpExporter.Flusher`. The handed-off effect is
+* best-effort and silently settles within two seconds.
 */
 const scheduleTelemetryFlush$1 = scheduleTelemetryFlush$2((flush) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)));
 function make$9(layer, optionsOrFetch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -64,7 +64,7 @@
     "@cloudflare/containers": "catalog:",
     "@cloudflare/vitest-pool-workers": "catalog:",
     "@cloudflare/workers-types": "catalog:",
-    "@effect/platform-node": "^4.0.0-beta.107 <4.0.0-rc.0",
+    "@effect/platform-node": "^4.0.0-rc.110",
     "@effect/sql-d1": "catalog:",
     "@effect/sql-pg": "catalog:",
     "@effect/sql-sqlite-do": "catalog:",
@@ -79,10 +79,10 @@
     "@cloudflare/computer": "^0.2.0",
     "@cloudflare/vitest-pool-workers": "^0.21.3",
     "@cloudflare/workers-types": "^4.20260611.1",
-    "@effect/sql-d1": "^4.0.0-beta.107 <4.0.0-rc.0",
-    "@effect/sql-pg": "^4.0.0-beta.107 <4.0.0-rc.0",
-    "@effect/sql-sqlite-do": "^4.0.0-beta.107 <4.0.0-rc.0",
-    "effect": "^4.0.0-beta.107 <4.0.0-rc.0"
+    "@effect/sql-d1": "^4.0.0-rc.110",
+    "@effect/sql-pg": "^4.0.0-rc.110",
+    "@effect/sql-sqlite-do": "^4.0.0-rc.110",
+    "effect": "^4.0.0-rc.110"
   },
   "peerDependenciesMeta": {
     "@cloudflare/computer": {

package/src/CloudflareOtlp.ts

@@ -5,16 +5,23 @@
  * telemetry on demand. Cloudflare isolates can freeze before the periodic
  * export interval fires. Effect-backed Worker fetch handlers, Worker or
  * Durable Object native RPC handlers, and Durable Object alarm handlers
- * schedule this flusher automatically.
- * Flush or scheduling failures do not replace the handler outcome and emit
- * only bounded framework diagnostics without attaching the foreign cause.
- * Other entrypoint lifecycles can flush explicitly or hand the flush to their
- * `waitUntil` mechanism:
+ * schedule this flusher automatically. These automatic flushes are capped at
+ * two seconds and silently discard timeouts and failures so telemetry cannot
+ * extend or fail the user event, or recursively log through an unhealthy
+ * exporter.
+ *
+ * Other entrypoint lifecycles, including queue handlers, do not flush
+ * automatically. Applications can flush explicitly or hand the flush to their
+ * `waitUntil` mechanism, and own the timeout and failure policy at that call
+ * site:
  *
  * ```ts
  * const flusher = yield* OtlpExporter.Flusher;
  *
- * yield* flusher.flush;
+ * yield* flusher.flush.pipe(
+ *   Effect.timeoutOption("2 seconds"),
+ *   Effect.ignoreCause,
+ * );
  * ```
  */
 import { ConfigProvider, Effect, Layer, Option } from "effect";

package/src/DurableObject.ts

@@ -108,7 +108,9 @@ export interface DurableObjectOptions<
    * Optional RPC methods exposed as Durable Object instance methods.
    *
    * After every invocation, the configured OTLP flusher is scheduled through
-   * `DurableObjectState.waitUntil`, including when the handler fails.
+   * `DurableObjectState.waitUntil`, including when the handler fails. The
+   * scheduled flush silently settles within two seconds even if the exporter
+   * does not.
    */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
@@ -125,7 +127,9 @@ export interface DurableObjectOptions<
    * Optional raw alarm handler.
    *
    * After every invocation, the configured OTLP flusher is scheduled through
-   * `DurableObjectState.waitUntil`, including when the handler fails.
+   * `DurableObjectState.waitUntil`, including when the handler fails. The
+   * scheduled flush silently settles within two seconds even if the exporter
+   * does not.
    */
   readonly alarm?: (
     alarmInfo?: globalThis.AlarmInvocationInfo,
@@ -196,6 +200,7 @@ export const make = <
         // SAFETY: event-layer bypass is used only for initialize; otherwise an absent layer means REvent is never.
         return Runtime.runEventPromise(
           this.runtime,
+          // @effect-diagnostics-next-line unsafeEffectTypeAssertion:off
           effect as Effect.Effect<A, E, HandlerContext<ROut>>,
         );
       }

package/src/DurableObjectStorage.ts

@@ -320,7 +320,12 @@ export const fromDurableObjectStorage = (
   transactionSync: <A, E, R>(closure: () => Effect.Effect<A, E, R>) =>
     Effect.context<R>().pipe(
       Effect.flatMap((context) =>
-        Effect.suspend(() => {
+        Effect.suspend((): Effect.Effect<A, E | StorageOperationError> => {
+          // Cloudflare rolls the transaction back when the callback throws, so a
+          // failed Exit is thrown to abort it. Keep a typed reference to that
+          // Exit rather than recovering its type from the untyped catch binding.
+          let aborted: Exit.Exit<A, E> | undefined;
+
           try {
             return Effect.succeed(
               storage.transactionSync(() => {
@@ -329,18 +334,14 @@ export const fromDurableObjectStorage = (
                 if (Exit.isSuccess(exit)) {
                   return exit.value;
                 }
+                aborted = exit;
 
                 throw exit;
               }),
             );
           } catch (cause) {
-            if (Exit.isExit(cause) && Exit.isFailure(cause)) {
-              // SAFETY: Exit.isFailure proves this cause carries the closure's typed E failure.
-              return Effect.failCause(cause.cause) as Effect.Effect<
-                A,
-                E | StorageOperationError,
-                R
-              >;
+            if (aborted !== undefined && cause === aborted && Exit.isFailure(aborted)) {
+              return Effect.failCause(aborted.cause);
             }
 
             return Effect.fail(storageError("transactionSync", cause));
@@ -352,6 +353,10 @@ export const fromDurableObjectStorage = (
     Effect.context<R>().pipe(
       Effect.flatMap((context) =>
         Effect.callback<A, E | StorageOperationError>((resume) => {
+          // See `transactionSync`: the thrown Exit aborts Cloudflare's
+          // transaction, and holding it here keeps its error type.
+          let aborted: Exit.Exit<A, E> | undefined;
+
           void storage
             .transaction(async (txn) => {
               const exit = await Effect.runPromiseExitWith(context)(
@@ -361,17 +366,15 @@ export const fromDurableObjectStorage = (
               if (Exit.isSuccess(exit)) {
                 return exit.value;
               }
+              aborted = exit;
 
               throw exit;
             })
             .then(
               (value) => resume(Effect.succeed(value)),
               (cause) => {
-                if (Exit.isExit(cause) && Exit.isFailure(cause)) {
-                  // SAFETY: Exit.isFailure proves this cause carries the closure's typed E failure.
-                  resume(
-                    Effect.failCause(cause.cause) as Effect.Effect<A, E | StorageOperationError>,
-                  );
+                if (aborted !== undefined && cause === aborted && Exit.isFailure(aborted)) {
+                  resume(Effect.failCause(aborted.cause));
                 } else {
                   resume(Effect.fail(storageError("transaction", cause)));
                 }

package/src/Worker.ts

@@ -185,7 +185,8 @@ export interface WorkerOptions<
    *
    * The layer is built inside the event's Effect scope and finalized when the
    * event effect completes. Use this for event-scoped resources such as OTLP
-   * trace/log exporters that should flush at event completion.
+   * trace/log exporters. Worker fetch and RPC handlers schedule a best-effort
+   * flush capped at two seconds; queue handlers do not flush automatically.
    */
   readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
   /** Main request handler. */
@@ -200,7 +201,8 @@ export interface WorkerOptions<
    * Optional RPC methods exposed as class instance methods.
    *
    * After every invocation, the configured OTLP flusher is scheduled through
-   * `WorkerContext.waitUntil`, including when the handler fails.
+   * `WorkerContext.waitUntil`, including when the handler fails. The scheduled
+   * flush silently settles within two seconds even if the exporter does not.
    */
   readonly rpc?: Rpc;
 }
@@ -300,7 +302,8 @@ const isWorkerOptions = <ROut, REvent, EventLayerError, Rpc extends WorkerRpc<RO
  *
  * 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`.
+ * context does not contain an `OtlpExporter.Flusher`. The handed-off effect is
+ * best-effort and silently settles within two seconds.
  */
 const scheduleTelemetryFlush: Effect.Effect<void, never, WorkerContext> =
   Telemetry.scheduleTelemetryFlush((flush) =>
@@ -389,6 +392,7 @@ export function make<
         // SAFETY: the public make overloads permit an absent event layer only when REvent is never.
         return Runtime.runEventPromise(
           this.runtime,
+          // @effect-diagnostics-next-line unsafeEffectTypeAssertion:off
           effect as Effect.Effect<A, E, RuntimeContext<ROut> | Scope.Scope>,
         );
       }

package/src/Workflow.ts

@@ -157,6 +157,7 @@ const fromWorkflowStep = (
                     Effect.provideService(
                       Effect.provideContext(
                         // SAFETY: WorkflowStepContext is provided immediately below; context supplies every other R service.
+                        // @effect-diagnostics-next-line unsafeEffectTypeAssertion:off
                         effect as Effect.Effect<A, E, Exclude<R, WorkflowStepContext>>,
                         context,
                       ),

package/src/internal/Telemetry.ts

@@ -1,14 +1,15 @@
 import { Effect, Option } from "effect";
 import { OtlpExporter } from "effect/unstable/observability";
 
-const logFlushFailure = Effect.logError("Telemetry flush failed").pipe(Effect.ignoreCause);
-
-const logFlushSchedulingFailure = Effect.logError("Telemetry flush scheduling failed").pipe(
-  Effect.ignoreCause,
-);
+/** Maximum event lifetime spent on an internally scheduled telemetry flush. */
+const scheduledFlushTimeout = "2 seconds";
 
 /**
  * Schedules a configured OTLP flusher through the current Cloudflare event.
+ *
+ * The handed-off effect is best-effort: it settles within two seconds and
+ * silently absorbs every failure cause so telemetry cannot extend or fail the
+ * user event, or recursively log through an unhealthy exporter.
  */
 export const scheduleTelemetryFlush = <R>(
   waitUntil: (flush: Effect.Effect<void>) => Effect.Effect<void, never, R>,
@@ -20,8 +21,14 @@ export const scheduleTelemetryFlush = <R>(
       return;
     }
 
-    // Exporters and platform schedulers are foreign boundaries. Preserve a
-    // useful diagnostic without retaining their arbitrary failure causes in
-    // logs, where payloads, headers, or credentials could otherwise escape.
-    yield* waitUntil(flusher.value.flush.pipe(Effect.catchCause(() => logFlushFailure)));
-  }).pipe(Effect.catchCause(() => logFlushSchedulingFailure));
+    // Exporters and platform schedulers are foreign boundaries. Do not log
+    // their arbitrary failure causes: the configured logger may be the same
+    // unhealthy OTLP exporter and recursively increase its backlog.
+    yield* waitUntil(
+      flusher.value.flush.pipe(
+        Effect.timeoutOption(scheduledFlushTimeout),
+        Effect.ignoreCause,
+        Effect.asVoid,
+      ),
+    );
+  }).pipe(Effect.ignoreCause);