effect-cf 0.25.0 → 0.25.2

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # effect-cf
 
+## 0.25.2
+
+### Patch Changes
+
+- [#90](https://github.com/danieljvdm/effect-cf/pull/90) [`56c1b2d`](https://github.com/danieljvdm/effect-cf/commit/56c1b2dfa30cbcc2336f28a8d8f7a48032f565df) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Flush configured OTLP telemetry after native Worker and Durable Object RPC handlers complete. Flush and scheduling failures keep the handler outcome unchanged and emit only bounded framework diagnostics.
+
+## 0.25.1
+
+### Patch Changes
+
+- [#88](https://github.com/danieljvdm/effect-cf/pull/88) [`18941d4`](https://github.com/danieljvdm/effect-cf/commit/18941d418c296c39a36d909516eb22a74778c8e7) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Upgrade to Effect 4 beta.107 and use its explicit environment-record config provider for
+  Cloudflare variables.
+
 ## 0.25.0
 
 ### Minor Changes

package/dist/{Binding-DI7u3fEY.d.mts → Binding-COCtoJXa.d.mts}

@@ -59,13 +59,16 @@ declare namespace WorkerConfig {
      * Keep empty-string env values as explicit `""` config values.
      *
      * By default (absent or `false`), empty strings are treated as missing
-     * config, matching `ConfigProvider.fromUnknown`.
+     * config, matching `ConfigProvider.fromEnvRecord`.
      */
     readonly preserveEmptyStrings?: boolean;
   }
   /**
    * Build a `ConfigProvider` from a Cloudflare worker `env` object.
    *
+   * Scalar vars and secrets use Effect's environment-record semantics;
+   * Cloudflare binding objects are ignored.
+   *
    * Empty-string values are treated as missing config by default; pass
    * `{ preserveEmptyStrings: true }` to keep them as explicit values.
    */

package/dist/{DurableObjectState-B5RCFnRy.mjs → DurableObjectState-CEh0DVw7.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Cause, Config, ConfigProvider, Context, Data, Effect, Exit, Option, Result, Schema } from "effect";
+import { Cause, Config, ConfigProvider, Context, Data, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
 //#region src/Environment.ts
 var Environment_exports = /* @__PURE__ */ __exportAll({
 	WorkerConfig: () => WorkerConfig,
@@ -16,7 +16,11 @@ let WorkerConfig;
 	_WorkerConfig.number = (name) => Config.number(name);
 	_WorkerConfig.integer = (name) => Config.int(name);
 	_WorkerConfig.boolean = (name) => Config.boolean(name);
-	const providerFromEnv = _WorkerConfig.providerFromEnv = (env, options) => ConfigProvider.fromUnknown(env, options);
+	const providerFromEnv = _WorkerConfig.providerFromEnv = (env, options) => {
+		const record = {};
+		for (const [key, value] of Object.entries(env)) if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) record[key] = String(value);
+		return ConfigProvider.fromEnvRecord(record, options);
+	};
 	const providerWith = _WorkerConfig.providerWith = (makeProvider) => Effect.map(WorkerEnvironment, makeProvider);
 	const provider = _WorkerConfig.provider = providerWith(providerFromEnv);
 	_WorkerConfig.providerLayer = ConfigProvider.layer(provider);

package/dist/{Hyperdrive-BwYp8Rsz.d.mts → Hyperdrive-6p59yyVk.d.mts}

@@ -1,4 +1,4 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DI7u3fEY.mjs";
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
 import { Context, Effect, Layer } from "effect";
 declare namespace Hyperdrive_d_exports {
   export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };

package/dist/HyperdrivePg.d.mts

@@ -1,5 +1,5 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DI7u3fEY.mjs";
-import { n as LayerOptions, r as TagClass } from "./Hyperdrive-BwYp8Rsz.mjs";
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
+import { n as LayerOptions, r as TagClass } from "./Hyperdrive-6p59yyVk.mjs";
 import { Layer } from "effect";
 import { PgClient } from "@effect/sql-pg";
 import { SqlClient, SqlError } from "effect/unstable/sql";

package/dist/Vitest.d.mts

@@ -1,5 +1,5 @@
-import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-DI7u3fEY.mjs";
-import { c as DurableObjectState, l as DurableObjectStateService, o as WorkflowInstanceStatusName } from "./WorkflowBinding--eMVaixT.mjs";
+import { c as WorkerEnvironment, s as WorkerEnv } from "./Binding-COCtoJXa.mjs";
+import { c as DurableObjectState, l as DurableObjectStateService, o as WorkflowInstanceStatusName } from "./WorkflowBinding-D5iWzCUa.mjs";
 import { Effect, Layer } 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,4 +1,4 @@
-import { d as WorkerConfig, f as WorkerEnvironment, r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-B5RCFnRy.mjs";
+import { d as WorkerConfig, f as WorkerEnvironment, r as fromDurableObjectState, t as DurableObjectState } from "./DurableObjectState-CEh0DVw7.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--eMVaixT.d.mts → WorkflowBinding-D5iWzCUa.d.mts}

@@ -1,4 +1,4 @@
-import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-DI7u3fEY.mjs";
+import { c as WorkerEnvironment, n as BindingService, r as BindingValidationError, s as WorkerEnv, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
 import { Cause, Context, Effect, Layer, Option, Schema, Scope } from "effect";
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
@@ -881,7 +881,12 @@ interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc e
   readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
   /** Queue consumer handler invoked per message batch. */
   readonly queue?: QueueHandler<RRuntime | REvent>;
-  /** Optional RPC methods exposed as class instance methods. */
+  /**
+   * 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.
+   */
   readonly rpc?: Rpc;
 }
 type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-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-DI7u3fEY.mjs";
-import { t as Hyperdrive_d_exports } from "./Hyperdrive-BwYp8Rsz.mjs";
-import { A as Rpc_d_exports, C as QueueBinding_d_exports, D as RpcDefinition_d_exports, E as ReservedMethodName$2, M as DurableWebSocket, N as DurableObjectStorage_d_exports, O as ServiceFreeSchema$1, P as StorageOperationError, S as QueueDefinition_d_exports, T as Method$2, _ as AsyncMethodArgs, a as WorkflowInstanceCreateOptions, b as AsyncMethodSuccess, c as DurableObjectState, d as ExecutionContext, f as NativeRequest, g as ServiceBinding_d_exports, h as WorkerDefinition_d_exports, i as WorkflowInstanceCreateBatchOptions, j as DurableObjectWebSocket_d_exports, k as Provider, m as Worker_d_exports, n as WorkflowBinding_d_exports, p as WorkerContext, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient, u as DurableObjectState_d_exports, v as AsyncMethodCloudflareReturn, w as Definition$4, x as Queue_d_exports, y as AsyncMethodKey } from "./WorkflowBinding--eMVaixT.mjs";
+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-COCtoJXa.mjs";
+import { t as Hyperdrive_d_exports } from "./Hyperdrive-6p59yyVk.mjs";
+import { A as Rpc_d_exports, C as QueueBinding_d_exports, D as RpcDefinition_d_exports, E as ReservedMethodName$2, M as DurableWebSocket, N as DurableObjectStorage_d_exports, O as ServiceFreeSchema$1, P as StorageOperationError, S as QueueDefinition_d_exports, T as Method$2, _ as AsyncMethodArgs, a as WorkflowInstanceCreateOptions, b as AsyncMethodSuccess, c as DurableObjectState, d as ExecutionContext, f as NativeRequest, g as ServiceBinding_d_exports, h as WorkerDefinition_d_exports, i as WorkflowInstanceCreateBatchOptions, j as DurableObjectWebSocket_d_exports, k as Provider, m as Worker_d_exports, n as WorkflowBinding_d_exports, p as WorkerContext, r as WorkflowInstance, s as WorkflowOperationError, t as WorkflowBindingClient, u as DurableObjectState_d_exports, v as AsyncMethodCloudflareReturn, w as Definition$4, x as Queue_d_exports, y as AsyncMethodKey } from "./WorkflowBinding-D5iWzCUa.mjs";
 import { Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
 import { Headers as Headers$1, HttpClient, HttpClientResponse } from "effect/unstable/http";
 import { OtlpExporter } from "effect/unstable/observability";
@@ -1099,7 +1099,12 @@ interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never
    * Object storage if work must happen only once per id.
    */
   readonly initialize?: Effect.Effect<void, unknown, HandlerContext<RRuntime>>;
-  /** Optional RPC methods exposed as Durable Object instance methods. */
+  /**
+   * 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.
+   */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
   readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as DurableObjectWebSocket_exports, c as causeMessage, d as WorkerConfig, f as WorkerEnvironment, i as fromExecutionContext, l as violationsMessage, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState, u as Environment_exports } from "./DurableObjectState-B5RCFnRy.mjs";
+import { a as DurableObjectWebSocket_exports, c as causeMessage, d as WorkerConfig, f as WorkerEnvironment, i as fromExecutionContext, l as violationsMessage, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState, u as Environment_exports } from "./DurableObjectState-CEh0DVw7.mjs";
 import { 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";
@@ -683,8 +683,12 @@ const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 *
 * Every layer exposes {@link OtlpExporter.Flusher}, which drains buffered
 * telemetry on demand. Cloudflare isolates can freeze before the periodic
-* export interval fires, so flush explicitly before returning a response, or
-* hand the flush to `ctx.waitUntil`:
+* export interval fires. Effect-backed Worker fetch handlers and Worker or
+* Durable Object native RPC 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:
 *
 * ```ts
 * const flusher = yield* OtlpExporter.Flusher;
@@ -1347,13 +1351,14 @@ const make$11 = (id, methods) => {
 //#endregion
 //#region src/internal/Entrypoint.ts
 const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
-const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run) => {
+const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run, onExit) => {
 	const methods = rpc ?? {};
 	assertNoReservedMethods(target, methods, reservedMethodNames);
 	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
 		enumerable: true,
 		value(...args) {
-			return run(this, Effect.suspend(() => method(...args)).pipe(Effect.mapError(encodeWireError)));
+			const handler = Effect.suspend(() => method(...args)).pipe(Effect.mapError(encodeWireError));
+			return run(this, onExit === void 0 ? handler : handler.pipe(Effect.onExit(() => onExit(this))));
 		}
 	});
 };
@@ -1386,6 +1391,18 @@ const runEventPromise = (runtime, effect, eventLayer) => {
 	return runtime.runPromise(Effect.scoped(withEventLayer));
 };
 //#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);
+/**
+* Schedules a configured OTLP flusher through the current Cloudflare event.
+*/
+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));
+//#endregion
 //#region src/Rpc.ts
 var Rpc_exports = /* @__PURE__ */ __exportAll({
 	RpcStub: () => RpcStub,
@@ -1755,10 +1772,7 @@ const isWorkerOptions = (options) => !Effect.isEffect(options);
 * (including streaming bodies still being consumed). It is a no-op when the
 * context does not contain an `OtlpExporter.Flusher`.
 */
-const scheduleTelemetryFlush = Effect.flatMap(Effect.serviceOption(OtlpExporter.Flusher), Option.match({
-	onNone: () => Effect.void,
-	onSome: (flusher) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flusher.flush))
-}));
+const scheduleTelemetryFlush$1 = scheduleTelemetryFlush$2((flush) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)));
 function make$9(layer, optionsOrFetch) {
 	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
 	class EffectWorker extends WorkerEntrypoint {
@@ -1778,7 +1792,7 @@ 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), Effect.provide(requestServices)));
+			return this[RunSymbol$1](renderFetchSuccess(fetchHandler).pipe(Effect.tap(() => scheduleTelemetryFlush$1), Effect.provide(requestServices)));
 		}
 		queue(batch) {
 			const queueHandler = options.queue;
@@ -1787,7 +1801,7 @@ function make$9(layer, optionsOrFetch) {
 			return this[RunSymbol$1](queueHandler(fromMessageBatch(batch, messages)));
 		}
 	}
-	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect));
+	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames$2, (self, effect) => self[RunSymbol$1](effect), () => scheduleTelemetryFlush$1);
 	return assumeEntrypointClass(EffectWorker);
 }
 /**
@@ -2080,6 +2094,7 @@ const reservedMethodNames = /* @__PURE__ */ new Set([
 	"webSocketError"
 ]);
 const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
+const scheduleTelemetryFlush = scheduleTelemetryFlush$2((flush) => Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)));
 /**
 * Creates a Durable Object class backed by a single managed Effect runtime.
 */
@@ -2120,7 +2135,7 @@ const make$7 = (layer, options = {}) => {
 			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), error));
 		}
 	}
-	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect));
+	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect) => self[RunSymbol](effect), () => scheduleTelemetryFlush);
 	return assumeEntrypointClass(EffectDurableObject);
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.25.0",
+  "version": "0.25.2",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -48,7 +48,7 @@
     "@cloudflare/containers": "catalog:",
     "@cloudflare/vitest-pool-workers": "catalog:",
     "@cloudflare/workers-types": "catalog:",
-    "@effect/platform-node": "^4.0.0-beta.105",
+    "@effect/platform-node": "^4.0.0-beta.107 <4.0.0-rc.0",
     "@effect/sql-d1": "catalog:",
     "@effect/sql-pg": "catalog:",
     "@effect/sql-sqlite-do": "catalog:",
@@ -60,10 +60,10 @@
   "peerDependencies": {
     "@cloudflare/vitest-pool-workers": "^0.21.3",
     "@cloudflare/workers-types": "^4.20260611.1",
-    "@effect/sql-d1": "^4.0.0-beta.105",
-    "@effect/sql-pg": "^4.0.0-beta.105",
-    "@effect/sql-sqlite-do": "^4.0.0-beta.105",
-    "effect": "^4.0.0-beta.105"
+    "@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"
   },
   "peerDependenciesMeta": {
     "@cloudflare/vitest-pool-workers": {

package/src/CloudflareOtlp.ts

@@ -3,8 +3,12 @@
  *
  * Every layer exposes {@link OtlpExporter.Flusher}, which drains buffered
  * telemetry on demand. Cloudflare isolates can freeze before the periodic
- * export interval fires, so flush explicitly before returning a response, or
- * hand the flush to `ctx.waitUntil`:
+ * export interval fires. Effect-backed Worker fetch handlers and Worker or
+ * Durable Object native RPC 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:
  *
  * ```ts
  * const flusher = yield* OtlpExporter.Flusher;

package/src/DurableObject.ts

@@ -7,6 +7,7 @@ import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";
 import * as Entrypoint from "./internal/Entrypoint";
 import * as Runtime from "./internal/Runtime";
+import * as Telemetry from "./internal/Telemetry";
 
 const reservedMethodNames = new Set<string>([
   "constructor",
@@ -29,6 +30,11 @@ type RunOptions = {
 
 const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
 
+const scheduleTelemetryFlush: Effect.Effect<void, never, DurableObjectState> =
+  Telemetry.scheduleTelemetryFlush((flush) =>
+    Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)),
+  );
+
 /**
  * Effect type for Durable Object lifecycle and RPC handlers.
  */
@@ -98,7 +104,12 @@ export interface DurableObjectOptions<
    * Object storage if work must happen only once per id.
    */
   readonly initialize?: Effect.Effect<void, unknown, HandlerContext<RRuntime>>;
-  /** Optional RPC methods exposed as Durable Object instance methods. */
+  /**
+   * 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.
+   */
   readonly rpc?: Rpc;
   /** Optional fetch handler for HTTP/WebSocket requests. */
   readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;
@@ -244,6 +255,7 @@ export const make = <
     options.rpc,
     reservedMethodNames,
     (self, effect) => self[RunSymbol](effect),
+    () => scheduleTelemetryFlush,
   );
 
   return Entrypoint.assumeEntrypointClass<DurableObjectClass<Rpc, ROut | REvent>>(

package/src/Environment.ts

@@ -1,4 +1,4 @@
-import { Config, ConfigProvider, Context, Effect, type Layer } from "effect";
+import { Config, ConfigProvider, Context, Effect, type Layer, Predicate } from "effect";
 
 /** Cloudflare worker environment object (`env`). */
 export type WorkerEnv = Cloudflare.Env;
@@ -78,7 +78,7 @@ export namespace WorkerConfig {
      * Keep empty-string env values as explicit `""` config values.
      *
      * By default (absent or `false`), empty strings are treated as missing
-     * config, matching `ConfigProvider.fromUnknown`.
+     * config, matching `ConfigProvider.fromEnvRecord`.
      */
     readonly preserveEmptyStrings?: boolean;
   }
@@ -86,11 +86,23 @@ export namespace WorkerConfig {
   /**
    * Build a `ConfigProvider` from a Cloudflare worker `env` object.
    *
+   * Scalar vars and secrets use Effect's environment-record semantics;
+   * Cloudflare binding objects are ignored.
+   *
    * Empty-string values are treated as missing config by default; pass
    * `{ preserveEmptyStrings: true }` to keep them as explicit values.
    */
-  export const providerFromEnv = (env: WorkerEnv, options?: ProviderOptions) =>
-    ConfigProvider.fromUnknown(env, options);
+  export const providerFromEnv = (env: WorkerEnv, options?: ProviderOptions) => {
+    const record: Record<string, string> = {};
+
+    for (const [key, value] of Object.entries(env)) {
+      if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) {
+        record[key] = String(value);
+      }
+    }
+
+    return ConfigProvider.fromEnvRecord(record, options);
+  };
 
   /**
    * Build a `ConfigProvider` from the current `WorkerEnvironment` with a custom

package/src/Worker.ts

@@ -1,21 +1,13 @@
 import { WorkerEntrypoint as CloudflareWorkerEntrypoint } from "cloudflare:workers";
-import {
-  type Cause,
-  Context,
-  Effect,
-  Layer,
-  type ManagedRuntime,
-  Option,
-  type Scope,
-} from "effect";
+import { type Cause, Context, Effect, Layer, type ManagedRuntime, type Scope } from "effect";
 import { HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { OtlpExporter } from "effect/unstable/observability";
 
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { fromMessage, fromMessageBatch, type QueueHandler } from "./Queue";
 import type * as RpcDefinition from "./RpcDefinition";
 import * as Entrypoint from "./internal/Entrypoint";
 import * as Runtime from "./internal/Runtime";
+import * as Telemetry from "./internal/Telemetry";
 import { fromExecutionContext } from "./internal/WorkerContext";
 
 /**
@@ -208,7 +200,12 @@ export interface WorkerOptions<
   >;
   /** Queue consumer handler invoked per message batch. */
   readonly queue?: QueueHandler<RRuntime | REvent>;
-  /** Optional RPC methods exposed as class instance methods. */
+  /**
+   * 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.
+   */
   readonly rpc?: Rpc;
 }
 
@@ -292,14 +289,10 @@ const isWorkerOptions = <ROut, REvent, EventLayerError, Rpc extends WorkerRpc<RO
  * (including streaming bodies still being consumed). It is a no-op when the
  * context does not contain an `OtlpExporter.Flusher`.
  */
-const scheduleTelemetryFlush: Effect.Effect<void, never, WorkerContext> = Effect.flatMap(
-  Effect.serviceOption(OtlpExporter.Flusher),
-  Option.match({
-    onNone: () => Effect.void,
-    onSome: (flusher) =>
-      Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flusher.flush)),
-  }),
-);
+const scheduleTelemetryFlush: Effect.Effect<void, never, WorkerContext> =
+  Telemetry.scheduleTelemetryFlush((flush) =>
+    Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)),
+  );
 
 /**
  * Creates a Cloudflare worker class backed by a single managed Effect runtime.
@@ -424,6 +417,7 @@ export function make<
     options.rpc,
     reservedMethodNames,
     (self, effect) => self[RunSymbol](effect),
+    () => scheduleTelemetryFlush,
   );
 
   return Entrypoint.assumeEntrypointClass<WorkerClass<Rpc, ROut | REvent>>(EffectWorker);

package/src/internal/Entrypoint.ts

@@ -19,6 +19,7 @@ export const defineEntrypointRpcMethods = <Self>(
   rpc: EntrypointRpc | undefined,
   reservedMethodNames: ReadonlySet<string>,
   run: (self: Self, effect: Effect.Effect<any, any, any>) => Promise<unknown>,
+  onExit?: (self: Self) => Effect.Effect<void, never, any>,
 ): void => {
   const methods = rpc ?? {};
 
@@ -28,11 +29,13 @@ export const defineEntrypointRpcMethods = <Self>(
     Object.defineProperty(prototype, key, {
       enumerable: true,
       value(this: Self, ...args: AnyArgs) {
+        const handler = Effect.suspend(() => method(...args)).pipe(
+          Effect.mapError(RpcDefinition.encodeWireError),
+        );
+
         return run(
           this,
-          Effect.suspend(() => method(...args)).pipe(
-            Effect.mapError(RpcDefinition.encodeWireError),
-          ),
+          onExit === undefined ? handler : handler.pipe(Effect.onExit(() => onExit(this))),
         );
       },
     });

package/src/internal/Telemetry.ts

@@ -0,0 +1,27 @@
+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,
+);
+
+/**
+ * Schedules a configured OTLP flusher through the current Cloudflare event.
+ */
+export const scheduleTelemetryFlush = <R>(
+  waitUntil: (flush: Effect.Effect<void>) => Effect.Effect<void, never, R>,
+): Effect.Effect<void, never, R> =>
+  Effect.gen(function* () {
+    const flusher = yield* Effect.serviceOption(OtlpExporter.Flusher);
+
+    if (Option.isNone(flusher)) {
+      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));