@effect-agent/storage-cloudflare 0.1.0-beta.37 → 0.1.0-beta.39

package/dist/testing.d.mts

@@ -0,0 +1,33 @@
+import { d as DoStorageFailpointLocation, n as DoStorageFailpointHandler, t as DoStorageFailpoint } from "./do-storage-failpoint-9XB9tuif.mjs";
+import { Context, Effect, Layer } from "effect";
+//#region src/do-storage-failpoint-testing.d.ts
+declare const DoStorageFailpointTestControl_base: Context.ServiceClass<DoStorageFailpointTestControl, "@effect-agent/storage-cloudflare/DoStorageFailpointTestControl", {
+  readonly clear: Effect.Effect<void>;
+  readonly setHandler: (handler: DoStorageFailpointHandler) => Effect.Effect<void>;
+}>;
+/** Test-only control for replacing the active Durable Object failpoint handler. */
+declare class DoStorageFailpointTestControl extends DoStorageFailpointTestControl_base {
+  /** Reusable test Layer with a control service backed by the same handler Ref. */
+  static readonly layer: Layer.Layer<DoStorageFailpoint | DoStorageFailpointTestControl, never, never>;
+}
+/**
+ * The DC-specific eviction failpoint mode: instead of failing typed, an armed hit evicts the
+ * Durable Object through an injected `evict` thunk — in production-shaped harnesses that thunk
+ * is `() => ctx.abort()`, the platform's real failure mode. `ctx.abort()` never returns (it
+ * throws while destroying the in-memory instance and every in-flight implicit or explicit
+ * storage transaction rolls back), so an armed hit ends the current Attempt exactly like an
+ * unannounced platform eviction; DO storage — the only correctness-critical state — survives
+ * for the next incarnation, which the persisted alarm wakes without any incoming request.
+ *
+ * The handles stay injected: this package never imports `cloudflare:workers`, so the harness
+ * that owns a `DurableObjectState` supplies the thunk.
+ */
+declare const evictionFailpointHandler: (options: {
+  readonly isArmed: (location: DoStorageFailpointLocation) => Effect.Effect<boolean>;
+  /** Kills the incarnation — e.g. `() => ctx.abort()`. Typed `void` because the platform
+   * declares `abort` as returning, but it throws while destroying the instance. */
+  readonly evict: (location: DoStorageFailpointLocation) => void;
+}) => DoStorageFailpointHandler;
+//#endregion
+export { DoStorageFailpointTestControl, evictionFailpointHandler };
+//# sourceMappingURL=testing.d.mts.map

package/dist/testing.mjs

@@ -0,0 +1,35 @@
+import { t as DoStorageFailpoint } from "./do-storage-failpoint-C-Qtchs7.mjs";
+import { Context, Effect, Layer, Ref } from "effect";
+//#region src/do-storage-failpoint-testing.ts
+const noFailpoint = () => Effect.void;
+/** Test-only control for replacing the active Durable Object failpoint handler. */
+var DoStorageFailpointTestControl = class DoStorageFailpointTestControl extends Context.Service()("@effect-agent/storage-cloudflare/DoStorageFailpointTestControl") {
+	/** Reusable test Layer with a control service backed by the same handler Ref. */
+	static layer = Layer.effectContext(Effect.gen(function* () {
+		const handler = yield* Ref.make(noFailpoint);
+		return Context.make(DoStorageFailpoint, DoStorageFailpoint.of({ hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))) })).pipe(Context.add(DoStorageFailpointTestControl, DoStorageFailpointTestControl.of({
+			clear: Ref.set(handler, noFailpoint),
+			setHandler: (next) => Ref.set(handler, next)
+		})));
+	}));
+};
+/**
+* The DC-specific eviction failpoint mode: instead of failing typed, an armed hit evicts the
+* Durable Object through an injected `evict` thunk — in production-shaped harnesses that thunk
+* is `() => ctx.abort()`, the platform's real failure mode. `ctx.abort()` never returns (it
+* throws while destroying the in-memory instance and every in-flight implicit or explicit
+* storage transaction rolls back), so an armed hit ends the current Attempt exactly like an
+* unannounced platform eviction; DO storage — the only correctness-critical state — survives
+* for the next incarnation, which the persisted alarm wakes without any incoming request.
+*
+* The handles stay injected: this package never imports `cloudflare:workers`, so the harness
+* that owns a `DurableObjectState` supplies the thunk.
+*/
+const evictionFailpointHandler = (options) => (location) => options.isArmed(location).pipe(Effect.flatMap((armed) => armed ? Effect.sync(() => {
+	options.evict(location);
+	throw new Error(`Durable Object eviction did not interrupt execution at ${location}.`);
+}) : Effect.void));
+//#endregion
+export { DoStorageFailpointTestControl, evictionFailpointHandler };
+
+//# sourceMappingURL=testing.mjs.map

package/dist/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","names":[],"sources":["../src/do-storage-failpoint-testing.ts"],"sourcesContent":["import { Context, Effect, Layer, Ref } from \"effect\";\n\nimport { DoStorageFailpoint, type DoStorageFailpointHandler } from \"./do-storage-failpoint.ts\";\nimport type { DoStorageFailpointLocation } from \"./errors.ts\";\n\nconst noFailpoint: DoStorageFailpointHandler = () => Effect.void;\n\n/** Test-only control for replacing the active Durable Object failpoint handler. */\nexport class DoStorageFailpointTestControl extends Context.Service<\n  DoStorageFailpointTestControl,\n  {\n    readonly clear: Effect.Effect<void>;\n    readonly setHandler: (handler: DoStorageFailpointHandler) => Effect.Effect<void>;\n  }\n>()(\"@effect-agent/storage-cloudflare/DoStorageFailpointTestControl\") {\n  /** Reusable test Layer with a control service backed by the same handler Ref. */\n  static readonly layer = Layer.effectContext(\n    Effect.gen(function* () {\n      const handler = yield* Ref.make<DoStorageFailpointHandler>(noFailpoint);\n      return Context.make(\n        DoStorageFailpoint,\n        DoStorageFailpoint.of({\n          hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))),\n        }),\n      ).pipe(\n        Context.add(\n          DoStorageFailpointTestControl,\n          DoStorageFailpointTestControl.of({\n            clear: Ref.set(handler, noFailpoint),\n            setHandler: (next) => Ref.set(handler, next),\n          }),\n        ),\n      );\n    }),\n  );\n}\n\n/**\n * The DC-specific eviction failpoint mode: instead of failing typed, an armed hit evicts the\n * Durable Object through an injected `evict` thunk — in production-shaped harnesses that thunk\n * is `() => ctx.abort()`, the platform's real failure mode. `ctx.abort()` never returns (it\n * throws while destroying the in-memory instance and every in-flight implicit or explicit\n * storage transaction rolls back), so an armed hit ends the current Attempt exactly like an\n * unannounced platform eviction; DO storage — the only correctness-critical state — survives\n * for the next incarnation, which the persisted alarm wakes without any incoming request.\n *\n * The handles stay injected: this package never imports `cloudflare:workers`, so the harness\n * that owns a `DurableObjectState` supplies the thunk.\n */\nexport const evictionFailpointHandler =\n  (options: {\n    readonly isArmed: (location: DoStorageFailpointLocation) => Effect.Effect<boolean>;\n    /** Kills the incarnation — e.g. `() => ctx.abort()`. Typed `void` because the platform\n     * declares `abort` as returning, but it throws while destroying the instance. */\n    readonly evict: (location: DoStorageFailpointLocation) => void;\n  }): DoStorageFailpointHandler =>\n  (location) =>\n    options.isArmed(location).pipe(\n      Effect.flatMap((armed) =>\n        armed\n          ? // `ctx.abort()` throws while destroying the instance; that throw surfaces as a\n            // defect in the (already dying) incarnation. The defensive throw below keeps the\n            // guarantee — nothing after an armed hit may observe in-memory state — even if a\n            // harness supplies an evict thunk that returns.\n            Effect.sync((): never => {\n              options.evict(location);\n              throw new Error(\n                `Durable Object eviction did not interrupt execution at ${location}.`,\n              );\n            })\n          : Effect.void,\n      ),\n    );\n"],"mappings":";;;AAKA,MAAM,oBAA+C,OAAO;;AAG5D,IAAa,gCAAb,MAAa,sCAAsC,QAAQ,QAMzD,CAAC,CAAC,gEAAgE,CAAC,CAAC;;CAEpE,OAAgB,QAAQ,MAAM,cAC5B,OAAO,IAAI,aAAa;EACtB,MAAM,UAAU,OAAO,IAAI,KAAgC,WAAW;EACtE,OAAO,QAAQ,KACb,oBACA,mBAAmB,GAAG,EACpB,MAAM,aAAa,IAAI,IAAI,OAAO,CAAC,CAAC,KAAK,OAAO,SAAS,YAAY,QAAQ,QAAQ,CAAC,CAAC,EACzF,CAAC,CACH,CAAC,CAAC,KACA,QAAQ,IACN,+BACA,8BAA8B,GAAG;GAC/B,OAAO,IAAI,IAAI,SAAS,WAAW;GACnC,aAAa,SAAS,IAAI,IAAI,SAAS,IAAI;EAC7C,CAAC,CACH,CACF;CACF,CAAC,CACH;AACF;;;;;;;;;;;;;AAcA,MAAa,4BACV,aAMA,aACC,QAAQ,QAAQ,QAAQ,CAAC,CAAC,KACxB,OAAO,SAAS,UACd,QAKI,OAAO,WAAkB;CACvB,QAAQ,MAAM,QAAQ;CACtB,MAAM,IAAI,MACR,0DAA0D,SAAS,EACrE;AACF,CAAC,IACD,OAAO,IACb,CACF"}

package/package.json

@@ -1,17 +1,23 @@
 {
   "name": "@effect-agent/storage-cloudflare",
-  "version": "0.1.0-beta.37",
+  "version": "0.1.0-beta.39",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.mts",
+      "default": "./dist/testing.mjs"
     }
   },
   "dependencies": {
-    "@effect-agent/session": "0.1.0-beta.37",
+    "@effect-agent/thread": "0.1.0-beta.39",
     "@effect/platform-browser": "4.0.0-rc.111",
-    "@effect/sql-sqlite-do": "4.0.0-rc.111",
-    "effect": "4.0.0-rc.111"
+    "@effect/sql-sqlite-do": "4.0.0-rc.111"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.0-rc.111"
   },
   "description": "Durable Object SQLite storage adapters and the routed port protocol for Effect Agent on Cloudflare.",
   "license": "MIT",
@@ -35,8 +41,9 @@
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "0.21.3",
     "@cloudflare/workers-types": "5.20260825.1",
-    "@effect-agent/testing": "0.1.0-beta.35",
+    "@effect-agent/testing": "0.1.0-beta.38",
     "@effect/vitest": "4.0.0-rc.111",
+    "effect": "4.0.0-rc.111",
     "typescript": "7.0.2",
     "vite-plus": "0.2.6",
     "vitest": "4.1.10"