effect-cf 0.42.0 → 0.43.0

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # effect-cf
 
+## 0.43.0
+
+### Minor Changes
+
+- [#174](https://github.com/danieljvdm/effect-cf/pull/174) [`10cd4a9`](https://github.com/danieljvdm/effect-cf/commit/10cd4a9cd162ef38599a53c772cdb19f8e241605) Thanks [@danieljvdm](https://github.com/danieljvdm)! - ## effect-cf
+
+  Require Effect `^4.0.0-rc.115` and matching `@effect/sql-d1`, `@effect/sql-pg`, and
+  `@effect/sql-sqlite-do` peers. Upgrade the Effect family together.
+
+  Preserve Cloudflare span context with Effect's new fiber representation and close
+  request scopes when HEAD or status 204, 205, or 304 omits an Effect streaming body.
+  Omitted streams are not started, and request resources and telemetry are finalized.
+
+  HyperdrivePg now uses Effect's native PostgreSQL driver. Consumers must account for
+  its new result codecs (`int8` becomes `bigint`, dates become strings, and timestamps
+  become epoch milliseconds), wrap JSON parameters with `sql.json`, and submit one
+  statement per query. The driver enables named prepared statements by default;
+  pass `prepare: false` for poolers that cannot preserve them.
+
+  ## effect-webtransport
+
+  Require Effect `^4.0.0-rc.115` and migrate the Socket adapter to scoped readers and
+  writers. Replace `socket.run(handler)` with a scoped acquisition of `socket.reader`
+  and a loop over `reader.pull`. Use `writer.write` and `writer.writeAll` after
+  acquiring `socket.writer`.
+
+  Reads now follow consumer demand without dispatching a fiber per chunk. Reader
+  scope cleanup still releases stream locks, sends FIN on success, and aborts writes
+  on failure. Releasing a writer scope half-closes the write side. Interrupting a
+  batch stops unsent frames while leaving the socket available for later writes.
+
+  Every close, including peer FIN, fails with a `SocketError` containing
+  `SocketCloseError`. Remove `closeCodeIsError`, `FromBidirectionalStreamOptions`,
+  and `defaultCloseCodeIsError`; handle close reasons in the read loop and use
+  `Effect.retry` around the scoped loop to reconnect. WebSocket fallback options now
+  accept `highWaterMark`.
+
+  MessagePack serialization was removed upstream. Use `RpcSerialization.layerNdjson`
+  or `RpcSerialization.layerSchemaBinary()` for the byte-stream transport.
+
+## 0.42.1
+
+### Patch Changes
+
+- [#171](https://github.com/danieljvdm/effect-cf/pull/171) [`06a0bfc`](https://github.com/danieljvdm/effect-cf/commit/06a0bfc1f750f5042e13f97b212c63ced5caa5e5) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Prevent the first Durable Object event from overtaking an initialization hook's concurrency gate while its service layer is still building. Hooks that perform background setup without a concurrency gate continue to allow incoming events.
+
+- [#170](https://github.com/danieljvdm/effect-cf/pull/170) [`4c41e8d`](https://github.com/danieljvdm/effect-cf/commit/4c41e8d648f340dbf43c5e2c17a850d967b7fa09) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Prevent Durable Object storage transactions and concurrency-blocking callbacks from stalling when their Effect work yields while an earlier timer is blocked by the native input gate.
+
 ## 0.42.0
 
 ### Minor Changes

package/README.md

@@ -3,7 +3,7 @@
 Cloudflare entrypoints and bindings as Effect services.
 
 ```sh
-npm install effect-cf "effect@^4.0.0-rc.112"
+npm install effect-cf "effect@^4.0.0-rc.115"
 ```
 
 The repository tests against workerd `1.20260825.1` and `@cloudflare/workers-types@5.20260825.1`. Use `compatibility_date: "2026-08-25"` in Wrangler.

package/dist/AnalyticsEngine.mjs

@@ -235,9 +235,9 @@ const makeClient = (definition, defaults) => (dataset) => {
 	};
 };
 const queryConfig = (options) => Config.all({
-	accountId: options?.accountId ?? Config.string("CLOUDFLARE_ACCOUNT_ID"),
-	apiToken: options?.apiToken ?? Config.redacted("CLOUDFLARE_API_TOKEN"),
-	apiBaseUrl: options?.apiBaseUrl ?? Config.string("CLOUDFLARE_API_BASE_URL").pipe(Config.withDefault(defaultQueryApiBaseUrl))
+	accountId: options?.accountId ?? Config.String("CLOUDFLARE_ACCOUNT_ID"),
+	apiToken: options?.apiToken ?? Config.Redacted("CLOUDFLARE_API_TOKEN"),
+	apiBaseUrl: options?.apiBaseUrl ?? Config.String("CLOUDFLARE_API_BASE_URL").pipe(Config.withDefault(defaultQueryApiBaseUrl))
 });
 const queryLayer = (tag, definition) => Layer.effect(tag, makeQueryClient(definition));
 const layerFetch = (tag, definition) => queryLayer(tag, definition).pipe(Layer.provide(FetchHttpClient.layer));

package/dist/CloudflareTracer.mjs

@@ -61,7 +61,7 @@ const layer = Layer.effect(Tracer.Tracer, Effect.sync(() => {
 			return parentContext(() => tracing.startActiveSpan(options.name, (span) => new Span(options, AsyncLocalStorage.snapshot(), span)));
 		},
 		context(primitive, fiber) {
-			return contextFor(fiber.currentSpan)(() => primitive["~effect/Effect/evaluate"](fiber));
+			return contextFor(fiber.cache.span)(() => primitive["~effect/Effect/evaluate"](fiber));
 		}
 	});
 }));

package/dist/DurableObject.d.mts

@@ -47,8 +47,10 @@ interface DurableObjectOptionsBase<RRuntime, REvent = never, EventLayerError = n
   /**
    * Effect run when Cloudflare loads this Durable Object instance into memory.
    *
-   * Use `DurableObjectState.blockConcurrencyWhile` inside this hook when
-   * incoming events should wait for setup to finish. Cloudflare may construct
+   * The base layer is acquired before incoming events are admitted. The hook
+   * itself runs in the background; start it with
+   * `DurableObjectState.blockConcurrencyWhile` when incoming events should
+   * wait for setup to finish. Cloudflare may construct
    * the same Durable Object id again after eviction or restart; use Durable
    * Object storage if work must happen only once per id.
    */

package/dist/DurableObject.mjs

@@ -10,6 +10,7 @@ import { DurableObjectAlarm } from "./DurableObjectAlarm.mjs";
 import { Tag, implement, method, native } from "./DurableObjectDefinition.mjs";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Scheduler from "effect/Scheduler";
 import { DurableObject } from "cloudflare:workers";
 import * as Tracer from "effect/Tracer";
 //#region src/DurableObject.ts
@@ -36,7 +37,10 @@ function make(layer, options = {}) {
 			const services = (registration?.layer ?? Layer.empty).pipe(Layer.provideMerge(baseServices));
 			this.runtime = makeEntrypointRuntime(layer, env, services);
 			const initialize = options.initialize;
-			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+			if (initialize !== void 0) state.waitUntil(state.blockConcurrencyWhile(async () => {
+				await Effect.runPromise(this.runtime.contextEffect, { scheduler: new Scheduler.MixedScheduler("sync") });
+				state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+			}));
 		}
 		[RunSymbol](effect, runOptions = {}) {
 			const eventLayer = runOptions.eventLayer === false ? void 0 : options.eventLayer;

package/dist/DurableObjectSqlite.mjs

@@ -3,8 +3,8 @@ 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 { SqliteClient } from "@effect/sql-sqlite-do";
 import * as Reactivity from "effect/unstable/reactivity/Reactivity";
 import { SqlClient } from "effect/unstable/sql";
 //#region src/DurableObjectSqlite.ts

package/dist/Environment.mjs

@@ -15,11 +15,11 @@ var Environment_exports = /* @__PURE__ */ __exportAll({
 var WorkerEnvironment = class extends Context.Service()("effect-cf/WorkerEnvironment") {};
 let WorkerConfig;
 (function(_WorkerConfig) {
-	_WorkerConfig.string = (name) => Config.string(name);
-	_WorkerConfig.redacted = (name) => Config.redacted(name);
-	_WorkerConfig.number = (name) => Config.number(name);
-	_WorkerConfig.integer = (name) => Config.int(name);
-	_WorkerConfig.boolean = (name) => Config.boolean(name);
+	_WorkerConfig.string = (name) => Config.String(name);
+	_WorkerConfig.redacted = (name) => Config.Redacted(name);
+	_WorkerConfig.number = (name) => Config.Number(name);
+	_WorkerConfig.integer = (name) => Config.Int(name);
+	_WorkerConfig.boolean = (name) => Config.Boolean(name);
 	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);

package/dist/Worker.mjs

@@ -58,8 +58,9 @@ const renderFetchSuccess = (effect, eventLayer) => Effect.suspend(() => {
 		return Effect.succeed(response);
 	});
 	const handleResponse = (request, response) => nativeResponse !== void 0 ? Effect.void : Effect.map(Effect.context(), (context) => {
-		webResponse = HttpServerResponse.toWeb(HttpEffect.scopeTransferToStream(response), {
-			withoutBody: request.method === "HEAD",
+		const withoutBody = request.method === "HEAD";
+		webResponse = HttpServerResponse.toWeb(HttpServerResponse.omitsBody(response, withoutBody) ? response : HttpEffect.scopeTransferToStream(response), {
+			withoutBody,
 			context
 		});
 	});

package/dist/internal/NativeCallback.mjs

@@ -1,7 +1,10 @@
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import "effect/Exit";
 import * as FiberSet from "effect/FiberSet";
+import * as Scheduler from "effect/Scheduler";
 //#region src/internal/NativeCallback.ts
+const callbackScheduler = new Scheduler.MixedScheduler("sync");
 /**
 * Runs an Effect callback owned by a native Promise operation.
 *
@@ -10,7 +13,7 @@ import * as FiberSet from "effect/FiberSet";
 * the native operation's settlement.
 */
 const runNativeCallback = Effect.fnUntraced(function* (operation) {
-	const callerContext = yield* Effect.context();
+	const callbackContext = Context.add(yield* Effect.context(), Scheduler.Scheduler, callbackScheduler);
 	return yield* Effect.scoped(Effect.gen(function* () {
 		let nativePromise;
 		yield* Effect.addFinalizer(() => {
@@ -20,7 +23,7 @@ const runNativeCallback = Effect.fnUntraced(function* (operation) {
 		const runPromise = yield* FiberSet.makeRuntimePromise();
 		return yield* Effect.callback((resume) => {
 			try {
-				nativePromise = operation((effect) => runPromise(Effect.provideContext(Effect.exit(effect), callerContext)));
+				nativePromise = operation((effect) => runPromise(Effect.provideContext(Effect.exit(effect), callbackContext)));
 			} catch (cause) {
 				resume(Effect.fail(cause));
 				return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -94,11 +94,11 @@
     "@cloudflare/sandbox": "^0.13.0-next.738.2",
     "@cloudflare/vitest-plugin": "^1.0.0",
     "@cloudflare/workers-types": "^5.20260825.1",
-    "@effect/sql-d1": "^4.0.0-rc.112",
-    "@effect/sql-pg": "^4.0.0-rc.112",
-    "@effect/sql-sqlite-do": "^4.0.0-rc.112",
+    "@effect/sql-d1": "^4.0.0-rc.115",
+    "@effect/sql-pg": "^4.0.0-rc.115",
+    "@effect/sql-sqlite-do": "^4.0.0-rc.115",
     "@modelcontextprotocol/server": "^2.0.0",
-    "effect": "^4.0.0-rc.112"
+    "effect": "^4.0.0-rc.115"
   },
   "peerDependenciesMeta": {
     "@cloudflare/computer": {

package/src/AnalyticsEngine.ts

@@ -729,11 +729,11 @@ export const makeClient =
 
 export const queryConfig = (options?: QueryConfigOptions) =>
   Config.all({
-    accountId: options?.accountId ?? Config.string("CLOUDFLARE_ACCOUNT_ID"),
-    apiToken: options?.apiToken ?? Config.redacted("CLOUDFLARE_API_TOKEN"),
+    accountId: options?.accountId ?? Config.String("CLOUDFLARE_ACCOUNT_ID"),
+    apiToken: options?.apiToken ?? Config.Redacted("CLOUDFLARE_API_TOKEN"),
     apiBaseUrl:
       options?.apiBaseUrl ??
-      Config.string("CLOUDFLARE_API_BASE_URL").pipe(Config.withDefault(defaultQueryApiBaseUrl)),
+      Config.String("CLOUDFLARE_API_BASE_URL").pipe(Config.withDefault(defaultQueryApiBaseUrl)),
   });
 
 export const queryLayer = <Self>(

package/src/CloudflareTracer.ts

@@ -91,7 +91,7 @@ export const layer: Layer.Layer<never> = Layer.effect(
         );
       },
       context(primitive, fiber) {
-        return contextFor(fiber.currentSpan)(() => primitive["~effect/Effect/evaluate"](fiber));
+        return contextFor(fiber.cache.span)(() => primitive["~effect/Effect/evaluate"](fiber));
       },
     });
   }),

package/src/DurableObject.ts

@@ -1,6 +1,7 @@
 import { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Scheduler from "effect/Scheduler";
 import * as Tracer from "effect/Tracer";
 import type { ManagedRuntime, Scope } from "effect";
 
@@ -125,8 +126,10 @@ interface DurableObjectOptionsBase<
   /**
    * Effect run when Cloudflare loads this Durable Object instance into memory.
    *
-   * Use `DurableObjectState.blockConcurrencyWhile` inside this hook when
-   * incoming events should wait for setup to finish. Cloudflare may construct
+   * The base layer is acquired before incoming events are admitted. The hook
+   * itself runs in the background; start it with
+   * `DurableObjectState.blockConcurrencyWhile` when incoming events should
+   * wait for setup to finish. Cloudflare may construct
    * the same Durable Object id again after eviction or restart; use Durable
    * Object storage if work must happen only once per id.
    */
@@ -298,7 +301,17 @@ export function make<
       const initialize = options.initialize;
 
       if (initialize !== undefined) {
-        state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+        state.waitUntil(
+          state.blockConcurrencyWhile(async () => {
+            // Build services before admitting the first event, then let the
+            // hook synchronously install its own gate if it needs one. Its
+            // background work and failure reporting keep their waitUntil owner.
+            await Effect.runPromise(this.runtime.contextEffect, {
+              scheduler: new Scheduler.MixedScheduler("sync"),
+            });
+            state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+          }),
+        );
       }
     }
 

package/src/Environment.ts

@@ -33,19 +33,19 @@ export namespace WorkerConfig {
   export type Key = ScalarConfigKey;
 
   /** Read a scalar Cloudflare var or secret as a string. */
-  export const string = <const Name extends Key>(name: Name) => Config.string(name);
+  export const string = <const Name extends Key>(name: Name) => Config.String(name);
 
   /** Read a scalar Cloudflare secret as a redacted string. */
-  export const redacted = <const Name extends Key>(name: Name) => Config.redacted(name);
+  export const redacted = <const Name extends Key>(name: Name) => Config.Redacted(name);
 
   /** Read a scalar Cloudflare var or secret as a number. */
-  export const number = <const Name extends Key>(name: Name) => Config.number(name);
+  export const number = <const Name extends Key>(name: Name) => Config.Number(name);
 
   /** Read a scalar Cloudflare var or secret as an integer. */
-  export const integer = <const Name extends Key>(name: Name) => Config.int(name);
+  export const integer = <const Name extends Key>(name: Name) => Config.Int(name);
 
   /** Read a scalar Cloudflare var or secret as a boolean. */
-  export const boolean = <const Name extends Key>(name: Name) => Config.boolean(name);
+  export const boolean = <const Name extends Key>(name: Name) => Config.Boolean(name);
 
   export interface ProviderOptions {
     /**

package/src/Worker.ts

@@ -277,10 +277,17 @@ const renderFetchSuccess = <E, R, REvent, EventLayerError, EventLayerRequirement
       nativeResponse !== undefined
         ? Effect.void
         : Effect.map(Effect.context<never>(), (context) => {
-            webResponse = HttpServerResponse.toWeb(HttpEffect.scopeTransferToStream(response), {
-              withoutBody: request.method === "HEAD",
-              context,
-            });
+            const withoutBody = request.method === "HEAD";
+
+            webResponse = HttpServerResponse.toWeb(
+              HttpServerResponse.omitsBody(response, withoutBody)
+                ? response
+                : HttpEffect.scopeTransferToStream(response),
+              {
+                withoutBody,
+                context,
+              },
+            );
           });
     const telemetryMiddleware = HttpMiddleware.make((self) =>
       RpcTargets.withScope(

package/src/internal/NativeCallback.ts

@@ -1,9 +1,13 @@
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as FiberSet from "effect/FiberSet";
+import * as Scheduler from "effect/Scheduler";
 
 type RunCallback<A, E, R> = (effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>>;
 
+const callbackScheduler = new Scheduler.MixedScheduler("sync");
+
 /**
  * Runs an Effect callback owned by a native Promise operation.
  *
@@ -14,7 +18,14 @@ type RunCallback<A, E, R> = (effect: Effect.Effect<A, E, R>) => Promise<Exit.Exi
 export const runNativeCallback = Effect.fnUntraced(function* <A, E, R, B>(
   operation: (run: RunCallback<A, E, R>) => Promise<B>,
 ): Effect.fn.Return<B, unknown, R> {
-  const callerContext = yield* Effect.context<R>();
+  // An older timer in the blocked parent input gate prevents later timers in
+  // this owner from running. Yield through microtasks while the native gate is
+  // held, including when the caller explicitly provided its own scheduler.
+  const callbackContext = Context.add(
+    yield* Effect.context<R>(),
+    Scheduler.Scheduler,
+    callbackScheduler,
+  );
 
   return yield* Effect.scoped(
     Effect.gen(function* () {
@@ -39,7 +50,7 @@ export const runNativeCallback = Effect.fnUntraced(function* <A, E, R, B>(
       return yield* Effect.callback<B, unknown>((resume) => {
         try {
           nativePromise = operation((effect) =>
-            runPromise(Effect.provideContext(Effect.exit(effect), callerContext)),
+            runPromise(Effect.provideContext(Effect.exit(effect), callbackContext)),
           );
         } catch (cause) {
           resume(Effect.fail(cause));