effect-cf 0.42.0 → 0.42.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # effect-cf
 
+## 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/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/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.42.1",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

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/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));