@smthrs/journal 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/migrations/0005_run_event_type.js

@@ -0,0 +1,40 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var run_event_type_exports = {};
+__export(run_event_type_exports, {
+  runEventType: () => runEventType
+});
+module.exports = __toCommonJS(run_event_type_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+const runEventType = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`CREATE INDEX flows_journal_events_run_event_type_idx ON flows_journal_events (run_id, event_type, seq)`;
+});
+//# sourceMappingURL=0005_run_event_type.js.map

package/dist/cjs/migrations/0005_run_event_type.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/migrations/0005_run_event_type.ts"],
+  "sourcesContent": ["/**\n * Indexed exact event-type reads within a run.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\n/**\n * Keeps filtered cursor reads proportional to the matching entries.\n *\n * @category migrations\n * @since 1.0.0\n */\nexport const runEventType: Effect.Effect<void, unknown, SqlClient.SqlClient> = Effect.gen(function*() {\n  const sql = yield* SqlClient.SqlClient\n  yield* sql`CREATE INDEX flows_journal_events_run_event_type_idx ON flows_journal_events (run_id, event_type, seq)`\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AACxB,gBAA2B;AAQpB,MAAM,eAAkE,OAAO,IAAI,aAAY;AACpG,QAAM,MAAM,OAAO,UAAU;AAC7B,SAAO;AACT,CAAC;",
+  "names": []
+}

package/dist/cjs/migrations/0006_consensus.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The `SqlConsensus` lease table.
+ *
+ * This is the private schema of the default consensus strategy: the owner
+ * tuple, the two-phase claim columns, and the grant timestamp relocated from
+ * `flows_runs`. Lease rows are strategy evidence, never history: heartbeats
+ * and lease state never enter the journal.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+/**
+ * Creates the `flows_consensus_leases` table and backfills a lease for every
+ * running or claimed run when `flows_runs` is already present, so an owner
+ * that was driving a run before this migration keeps its fence afterwards.
+ *
+ * @category migrations
+ * @since 1.0.0
+ */
+export declare const consensus: Effect.Effect<void, unknown, SqlClient.SqlClient>;
+//# sourceMappingURL=0006_consensus.d.ts.map

package/dist/cjs/migrations/0006_consensus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"0006_consensus.d.ts","sourceRoot":"","sources":["../../../src/migrations/0006_consensus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAE1D;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,SAAS,CA2DtE,CAAA"}

package/dist/cjs/migrations/0006_consensus.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var consensus_exports = {};
+__export(consensus_exports, {
+  consensus: () => consensus
+});
+module.exports = __toCommonJS(consensus_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+const consensus = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`CREATE TABLE flows_consensus_leases (
+    run_id TEXT PRIMARY KEY CHECK (length(run_id) > 0),
+    owner_host_id TEXT,
+    owner_pid ${Dialect.integer(sql)} CHECK (owner_pid IS NULL OR (${Dialect.isInteger(sql, sql`owner_pid`)} AND owner_pid >= 0)),
+    owner_nonce TEXT,
+    granted_at_ms ${Dialect.integer(sql)} CHECK (granted_at_ms IS NULL OR (${Dialect.isInteger(sql, sql`granted_at_ms`)} AND granted_at_ms >= 0)),
+    heartbeat_at_ms ${Dialect.integer(sql)} CHECK (heartbeat_at_ms IS NULL OR (${Dialect.isInteger(sql, sql`heartbeat_at_ms`)} AND heartbeat_at_ms >= 0)),
+    claim_host_id TEXT,
+    claim_pid ${Dialect.integer(sql)} CHECK (claim_pid IS NULL OR (${Dialect.isInteger(sql, sql`claim_pid`)} AND claim_pid >= 0)),
+    claim_nonce TEXT,
+    claimed_at_ms ${Dialect.integer(sql)} CHECK (claimed_at_ms IS NULL OR (${Dialect.isInteger(sql, sql`claimed_at_ms`)} AND claimed_at_ms >= 0))
+  )`;
+  const tables = yield* Dialect.tables(sql);
+  if (!tables.some((table) => table.name === "flows_runs")) {
+    return;
+  }
+  yield* sql`
+    INSERT INTO flows_consensus_leases (
+      run_id,
+      owner_host_id,
+      owner_pid,
+      owner_nonce,
+      granted_at_ms,
+      heartbeat_at_ms,
+      claim_host_id,
+      claim_pid,
+      claim_nonce,
+      claimed_at_ms
+    )
+    SELECT
+      run_id,
+      owner_host_id,
+      owner_pid,
+      owner_nonce,
+      CASE WHEN status = 'running' THEN heartbeat_at_ms ELSE NULL END,
+      CASE WHEN status = 'running' THEN heartbeat_at_ms ELSE NULL END,
+      claim_host_id,
+      claim_pid,
+      claim_nonce,
+      claimed_at_ms
+    FROM flows_runs
+    WHERE status = 'running' OR claim_host_id IS NOT NULL
+    ON CONFLICT (run_id) DO NOTHING
+  `;
+});
+//# sourceMappingURL=0006_consensus.js.map

package/dist/cjs/migrations/0006_consensus.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/migrations/0006_consensus.ts"],
+  "sourcesContent": ["/**\n * The `SqlConsensus` lease table.\n *\n * This is the private schema of the default consensus strategy: the owner\n * tuple, the two-phase claim columns, and the grant timestamp relocated from\n * `flows_runs`. Lease rows are strategy evidence, never history: heartbeats\n * and lease state never enter the journal.\n *\n * @since 1.0.0\n */\n\nimport * as Dialect from \"@smthrs/database/Dialect\"\nimport * as Effect from \"effect/Effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\n/**\n * Creates the `flows_consensus_leases` table and backfills a lease for every\n * running or claimed run when `flows_runs` is already present, so an owner\n * that was driving a run before this migration keeps its fence afterwards.\n *\n * @category migrations\n * @since 1.0.0\n */\nexport const consensus: Effect.Effect<void, unknown, SqlClient.SqlClient> = Effect.gen(function*() {\n  const sql = yield* SqlClient.SqlClient\n\n  yield* sql`CREATE TABLE flows_consensus_leases (\n    run_id TEXT PRIMARY KEY CHECK (length(run_id) > 0),\n    owner_host_id TEXT,\n    owner_pid ${Dialect.integer(sql)} CHECK (owner_pid IS NULL OR (${\n    Dialect.isInteger(sql, sql`owner_pid`)\n  } AND owner_pid >= 0)),\n    owner_nonce TEXT,\n    granted_at_ms ${Dialect.integer(sql)} CHECK (granted_at_ms IS NULL OR (${\n    Dialect.isInteger(sql, sql`granted_at_ms`)\n  } AND granted_at_ms >= 0)),\n    heartbeat_at_ms ${Dialect.integer(sql)} CHECK (heartbeat_at_ms IS NULL OR (${\n    Dialect.isInteger(sql, sql`heartbeat_at_ms`)\n  } AND heartbeat_at_ms >= 0)),\n    claim_host_id TEXT,\n    claim_pid ${Dialect.integer(sql)} CHECK (claim_pid IS NULL OR (${\n    Dialect.isInteger(sql, sql`claim_pid`)\n  } AND claim_pid >= 0)),\n    claim_nonce TEXT,\n    claimed_at_ms ${Dialect.integer(sql)} CHECK (claimed_at_ms IS NULL OR (${\n    Dialect.isInteger(sql, sql`claimed_at_ms`)\n  } AND claimed_at_ms >= 0))\n  )`\n\n  const tables = yield* Dialect.tables(sql)\n  if (!tables.some((table) => table.name === \"flows_runs\")) {\n    return\n  }\n\n  yield* sql`\n    INSERT INTO flows_consensus_leases (\n      run_id,\n      owner_host_id,\n      owner_pid,\n      owner_nonce,\n      granted_at_ms,\n      heartbeat_at_ms,\n      claim_host_id,\n      claim_pid,\n      claim_nonce,\n      claimed_at_ms\n    )\n    SELECT\n      run_id,\n      owner_host_id,\n      owner_pid,\n      owner_nonce,\n      CASE WHEN status = 'running' THEN heartbeat_at_ms ELSE NULL END,\n      CASE WHEN status = 'running' THEN heartbeat_at_ms ELSE NULL END,\n      claim_host_id,\n      claim_pid,\n      claim_nonce,\n      claimed_at_ms\n    FROM flows_runs\n    WHERE status = 'running' OR claim_host_id IS NOT NULL\n    ON CONFLICT (run_id) DO NOTHING\n  `\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,cAAyB;AACzB,aAAwB;AACxB,gBAA2B;AAUpB,MAAM,YAA+D,OAAO,IAAI,aAAY;AACjG,QAAM,MAAM,OAAO,UAAU;AAE7B,SAAO;AAAA;AAAA;AAAA,gBAGO,QAAQ,QAAQ,GAAG,CAAC,iCAChC,QAAQ,UAAU,KAAK,cAAc,CACvC;AAAA;AAAA,oBAEkB,QAAQ,QAAQ,GAAG,CAAC,qCACpC,QAAQ,UAAU,KAAK,kBAAkB,CAC3C;AAAA,sBACoB,QAAQ,QAAQ,GAAG,CAAC,uCACtC,QAAQ,UAAU,KAAK,oBAAoB,CAC7C;AAAA;AAAA,gBAEc,QAAQ,QAAQ,GAAG,CAAC,iCAChC,QAAQ,UAAU,KAAK,cAAc,CACvC;AAAA;AAAA,oBAEkB,QAAQ,QAAQ,GAAG,CAAC,qCACpC,QAAQ,UAAU,KAAK,kBAAkB,CAC3C;AAAA;AAGA,QAAM,SAAS,OAAO,QAAQ,OAAO,GAAG;AACxC,MAAI,CAAC,OAAO,KAAK,CAAC,UAAU,MAAM,SAAS,YAAY,GAAG;AACxD;AAAA,EACF;AAEA,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BT,CAAC;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/test/Notifying.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Effect-native analogue of Bazel Skyframe's `NotifyingHelper` and
+ * `NotifyingInMemoryGraph`: wrap a record-of-Effect-methods service so a listener hook fires around
+ * every operation. The hook runs in the calling fiber, so a hook that dies,
+ * interrupts, or awaits a `Latch` injects crashes, fence loss, and exact
+ * sequencing at any durable transition point, the mechanism that makes
+ * interstitial interleaving bugs testable at all.
+ *
+ * Deliberately NOT ported from Skyframe: `DeterministicHelper`'s
+ * deterministic-scheduler machinery, `ChainedFunction`, and `TrackingAwaiter`.
+ * Effect already gives us deterministic fibers, `TestClock`, `Latch`, and
+ * failure propagation across fiber joins, so those helpers have no residue
+ * here.
+ *
+ * @since 0.1.0
+ */
+import type * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * Whether the hook is firing before or after the delegated operation.
+ * Skyframe's `NotifyingHelper.Order`, minus its `BEFORE_AND_AFTER` (pass the
+ * same hook body for both firings instead).
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Order = "before" | "after";
+/**
+ * Listener invoked around every delegated operation. `op` is the service
+ * method name (Skyframe's `EventType`, but open-world), `args` the call
+ * arguments. Express crash injection as `Effect.die` or `Effect.interrupt`
+ * inside the hook, the hook's type stays `Effect<void>` so the wrapped
+ * service is structurally identical to the real one.
+ *
+ * The `after` firing only happens when the operation succeeds; a failed
+ * operation already is the interesting event.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Hook = (op: string, order: Order, args: ReadonlyArray<unknown>) => Effect.Effect<void>;
+/**
+ * Wraps a service so `hook(op, "before" | "after", args)` fires around every
+ * Effect-valued operation, delegating to the real implementation in between.
+ *
+ * Generic over any record-of-Effect-methods service (`Journal`, `CacheStore`,
+ * `AttemptStore`, `RunStore`, ...): Effect-returning methods and plain Effect
+ * properties are hooked; non-Effect members (e.g. `Stream`-returning methods)
+ * delegate untouched.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const wrap: <S extends object>(service: S, hook: Hook) => S;
+/**
+ * Layer form of {@link wrap}: reads the real service from the environment and
+ * re-provides the notifying wrapper under the same key, so an existing stack
+ * gains a listener without touching its construction.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: <Id, S extends object>(tag: Context.Key<Id, S>, hook: Hook) => Layer.Layer<Id, never, Id>;
+//# sourceMappingURL=Notifying.d.ts.map

package/dist/cjs/test/Notifying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Notifying.d.ts","sourceRoot":"","sources":["../../../src/test/Notifying.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC;;;;;;;GAOG;AACH,MAAM,MAAM,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAA;AAEtC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,IAAI,GAAG,CACjB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,KACzB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;AAExB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,IAAI,KAAG,CAyB/D,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,GAAI,EAAE,EAAE,CAAC,SAAS,MAAM,EACxC,KAAK,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EACvB,MAAM,IAAI,KACT,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,CAAyE,CAAA"}

package/dist/cjs/test/Notifying.js

@@ -0,0 +1,62 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Notifying_exports = {};
+__export(Notifying_exports, {
+  layer: () => layer,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(Notifying_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+const wrap = (service, hook) => {
+  const wrapped = {};
+  for (const key of Object.keys(service)) {
+    const value = service[key];
+    if (Effect.isEffect(value)) {
+      wrapped[key] = hook(key, "before", []).pipe(
+        Effect.andThen(value),
+        Effect.tap(() => hook(key, "after", []))
+      );
+    } else if (typeof value === "function") {
+      const method = value;
+      wrapped[key] = (...args) => {
+        const result = method.apply(service, args);
+        return Effect.isEffect(result) ? hook(key, "before", args).pipe(
+          Effect.andThen(result),
+          Effect.tap(() => hook(key, "after", args))
+        ) : result;
+      };
+    } else {
+      wrapped[key] = value;
+    }
+  }
+  return wrapped;
+};
+const layer = (tag, hook) => Layer.effect(tag)(Effect.map(tag, (service) => wrap(service, hook)));
+//# sourceMappingURL=Notifying.js.map

package/dist/cjs/test/Notifying.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/test/Notifying.ts"],
+  "sourcesContent": ["/**\n * Effect-native analogue of Bazel Skyframe's `NotifyingHelper` and\n * `NotifyingInMemoryGraph`: wrap a record-of-Effect-methods service so a listener hook fires around\n * every operation. The hook runs in the calling fiber, so a hook that dies,\n * interrupts, or awaits a `Latch` injects crashes, fence loss, and exact\n * sequencing at any durable transition point, the mechanism that makes\n * interstitial interleaving bugs testable at all.\n *\n * Deliberately NOT ported from Skyframe: `DeterministicHelper`'s\n * deterministic-scheduler machinery, `ChainedFunction`, and `TrackingAwaiter`.\n * Effect already gives us deterministic fibers, `TestClock`, `Latch`, and\n * failure propagation across fiber joins, so those helpers have no residue\n * here.\n *\n * @since 0.1.0\n */\n\nimport type * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\n\n/**\n * Whether the hook is firing before or after the delegated operation.\n * Skyframe's `NotifyingHelper.Order`, minus its `BEFORE_AND_AFTER` (pass the\n * same hook body for both firings instead).\n *\n * @category models\n * @since 0.1.0\n */\nexport type Order = \"before\" | \"after\"\n\n/**\n * Listener invoked around every delegated operation. `op` is the service\n * method name (Skyframe's `EventType`, but open-world), `args` the call\n * arguments. Express crash injection as `Effect.die` or `Effect.interrupt`\n * inside the hook, the hook's type stays `Effect<void>` so the wrapped\n * service is structurally identical to the real one.\n *\n * The `after` firing only happens when the operation succeeds; a failed\n * operation already is the interesting event.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Hook = (\n  op: string,\n  order: Order,\n  args: ReadonlyArray<unknown>\n) => Effect.Effect<void>\n\n/**\n * Wraps a service so `hook(op, \"before\" | \"after\", args)` fires around every\n * Effect-valued operation, delegating to the real implementation in between.\n *\n * Generic over any record-of-Effect-methods service (`Journal`, `CacheStore`,\n * `AttemptStore`, `RunStore`, ...): Effect-returning methods and plain Effect\n * properties are hooked; non-Effect members (e.g. `Stream`-returning methods)\n * delegate untouched.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const wrap = <S extends object>(service: S, hook: Hook): S => {\n  const wrapped: Record<string, unknown> = {}\n  for (const key of Object.keys(service)) {\n    const value = (service as Record<string, unknown>)[key]\n    if (Effect.isEffect(value)) {\n      wrapped[key] = hook(key, \"before\", []).pipe(\n        Effect.andThen(value as Effect.Effect<unknown, unknown, unknown>),\n        Effect.tap(() => hook(key, \"after\", []))\n      )\n    } else if (typeof value === \"function\") {\n      const method = value as (...args: Array<unknown>) => unknown\n      wrapped[key] = (...args: Array<unknown>) => {\n        const result = method.apply(service, args)\n        return Effect.isEffect(result)\n          ? hook(key, \"before\", args).pipe(\n            Effect.andThen(result as Effect.Effect<unknown, unknown, unknown>),\n            Effect.tap(() => hook(key, \"after\", args))\n          )\n          : result\n      }\n    } else {\n      wrapped[key] = value\n    }\n  }\n  return wrapped as S\n}\n\n/**\n * Layer form of {@link wrap}: reads the real service from the environment and\n * re-provides the notifying wrapper under the same key, so an existing stack\n * gains a listener without touching its construction.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer = <Id, S extends object>(\n  tag: Context.Key<Id, S>,\n  hook: Hook\n): Layer.Layer<Id, never, Id> => Layer.effect(tag)(Effect.map(tag, (service) => wrap(service, hook)))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,aAAwB;AACxB,YAAuB;AA2ChB,MAAM,OAAO,CAAmB,SAAY,SAAkB;AACnE,QAAM,UAAmC,CAAC;AAC1C,aAAW,OAAO,OAAO,KAAK,OAAO,GAAG;AACtC,UAAM,QAAS,QAAoC,GAAG;AACtD,QAAI,OAAO,SAAS,KAAK,GAAG;AAC1B,cAAQ,GAAG,IAAI,KAAK,KAAK,UAAU,CAAC,CAAC,EAAE;AAAA,QACrC,OAAO,QAAQ,KAAiD;AAAA,QAChE,OAAO,IAAI,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC;AAAA,MACzC;AAAA,IACF,WAAW,OAAO,UAAU,YAAY;AACtC,YAAM,SAAS;AACf,cAAQ,GAAG,IAAI,IAAI,SAAyB;AAC1C,cAAM,SAAS,OAAO,MAAM,SAAS,IAAI;AACzC,eAAO,OAAO,SAAS,MAAM,IACzB,KAAK,KAAK,UAAU,IAAI,EAAE;AAAA,UAC1B,OAAO,QAAQ,MAAkD;AAAA,UACjE,OAAO,IAAI,MAAM,KAAK,KAAK,SAAS,IAAI,CAAC;AAAA,QAC3C,IACE;AAAA,MACN;AAAA,IACF,OAAO;AACL,cAAQ,GAAG,IAAI;AAAA,IACjB;AAAA,EACF;AACA,SAAO;AACT;AAUO,MAAM,QAAQ,CACnB,KACA,SAC+B,MAAM,OAAO,GAAG,EAAE,OAAO,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,IAAI,CAAC,CAAC;",
+  "names": []
+}

package/dist/cjs/test/TestJournal.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Deterministic bundle of the production journal service.
+ *
+ * This provides the journal and nothing else. A consumer that also needs run
+ * state or the step cache composes `@smthrs/run-store/test/TestRunStore` and
+ * `@smthrs/step-cache/test/TestCacheStore` over the same database, or takes
+ * the whole engine bundle from `@smthrs/engine-store/test/TestStores`.
+ *
+ * @since 0.1.0
+ */
+import * as Layer from "effect/Layer";
+import * as SqlJournal from "../SqlJournal.ts";
+/**
+ * Options for the deterministic journal bundle.
+ *
+ * The production options with `capacity` and `overflow` made optional. Every
+ * field forwards to {@link SqlJournal.layer} unchanged, so a suite can exercise
+ * index-bound eviction, the entry byte bound, a custom or noop redactor, and
+ * the compaction policy through the bundle instead of hand-assembling the layer
+ * stack the bundle exists to hide.
+ *
+ * The type is derived rather than mirrored because a mirror silently falls
+ * behind: the hand-copied list had already lost `maxEntryBytes`, so the one
+ * production bound a hostile-payload suite needs was unreachable here.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface TestJournalOptions extends Omit<SqlJournal.SqlJournalOptions, "capacity" | "overflow"> {
+    /** Admission-queue bound and `changes` buffer size. Defaults to 1024. */
+    readonly capacity?: number | undefined;
+    /** Policy applied when the admission queue is full. Defaults to `reject`. */
+    readonly overflow?: SqlJournal.SqlJournalOptions["overflow"] | undefined;
+}
+/**
+ * Provides the production SQLite journal over an in-memory database.
+ * Migrations run before the journal is exposed.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: (options?: TestJournalOptions) => Layer.Layer<import("../Journal.ts").Journal, import("effect/unstable/sql/SqlError").SqlError | import("../Journal.ts").JournalError | import("effect/unstable/sql/Migrator").MigrationError, never>;
+//# sourceMappingURL=TestJournal.d.ts.map

package/dist/cjs/test/TestJournal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestJournal.d.ts","sourceRoot":"","sources":["../../../src/test/TestJournal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAA;AAE9C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,UAAU,GAAG,UAAU,CAAC;IACrG,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,UAAU,CAAC,GAAG,SAAS,CAAA;CACzE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,GAAI,UAAU,kBAAkB,wMAKgC,CAAA"}

package/dist/cjs/test/TestJournal.js

@@ -0,0 +1,43 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TestJournal_exports = {};
+__export(TestJournal_exports, {
+  layer: () => layer
+});
+module.exports = __toCommonJS(TestJournal_exports);
+var TestDatabase = __toESM(require("@smthrs/database/test/TestDatabase"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Migrations = __toESM(require("../Migrations.js"), 1);
+var SqlJournal = __toESM(require("../SqlJournal.js"), 1);
+const layer = (options) => SqlJournal.layer({
+  ...options,
+  capacity: options?.capacity ?? 1024,
+  overflow: options?.overflow ?? "reject"
+}).pipe(Layer.provide(Layer.provideMerge(Migrations.layer, TestDatabase.layer)));
+//# sourceMappingURL=TestJournal.js.map

package/dist/cjs/test/TestJournal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/test/TestJournal.ts"],
+  "sourcesContent": ["/**\n * Deterministic bundle of the production journal service.\n *\n * This provides the journal and nothing else. A consumer that also needs run\n * state or the step cache composes `@smthrs/run-store/test/TestRunStore` and\n * `@smthrs/step-cache/test/TestCacheStore` over the same database, or takes\n * the whole engine bundle from `@smthrs/engine-store/test/TestStores`.\n *\n * @since 0.1.0\n */\n\nimport * as TestDatabase from \"@smthrs/database/test/TestDatabase\"\nimport * as Layer from \"effect/Layer\"\nimport * as Migrations from \"../Migrations.ts\"\nimport * as SqlJournal from \"../SqlJournal.ts\"\n\n/**\n * Options for the deterministic journal bundle.\n *\n * The production options with `capacity` and `overflow` made optional. Every\n * field forwards to {@link SqlJournal.layer} unchanged, so a suite can exercise\n * index-bound eviction, the entry byte bound, a custom or noop redactor, and\n * the compaction policy through the bundle instead of hand-assembling the layer\n * stack the bundle exists to hide.\n *\n * The type is derived rather than mirrored because a mirror silently falls\n * behind: the hand-copied list had already lost `maxEntryBytes`, so the one\n * production bound a hostile-payload suite needs was unreachable here.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface TestJournalOptions extends Omit<SqlJournal.SqlJournalOptions, \"capacity\" | \"overflow\"> {\n  /** Admission-queue bound and `changes` buffer size. Defaults to 1024. */\n  readonly capacity?: number | undefined\n  /** Policy applied when the admission queue is full. Defaults to `reject`. */\n  readonly overflow?: SqlJournal.SqlJournalOptions[\"overflow\"] | undefined\n}\n\n/**\n * Provides the production SQLite journal over an in-memory database.\n * Migrations run before the journal is exposed.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer = (options?: TestJournalOptions) =>\n  SqlJournal.layer({\n    ...options,\n    capacity: options?.capacity ?? 1024,\n    overflow: options?.overflow ?? \"reject\"\n  }).pipe(Layer.provide(Layer.provideMerge(Migrations.layer, TestDatabase.layer)))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,mBAA8B;AAC9B,YAAuB;AACvB,iBAA4B;AAC5B,iBAA4B;AAgCrB,MAAM,QAAQ,CAAC,YACpB,WAAW,MAAM;AAAA,EACf,GAAG;AAAA,EACH,UAAU,SAAS,YAAY;AAAA,EAC/B,UAAU,SAAS,YAAY;AACjC,CAAC,EAAE,KAAK,MAAM,QAAQ,MAAM,aAAa,WAAW,OAAO,aAAa,KAAK,CAAC,CAAC;",
+  "names": []
+}

package/dist/esm/CallFact.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Versioned facts for an authorized native cell invocation and its delivered result.
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context";
+import * as Schema from "effect/Schema";
+/** Stable harness coordinates, independent of physical attempt or publication order.
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Identity: Schema.Struct<{
+    /** Public logical run identity, not an authentication session credential. */
+    readonly runId: Schema.String;
+    readonly frame: Schema.Int;
+    readonly cell: Schema.String;
+    readonly ordinal: Schema.Int;
+    readonly declaration: Schema.String;
+    readonly layers: Schema.$Array<Schema.String>;
+}>;
+/** A call annotation contains data only and never changes an action key.
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Call: Schema.Struct<{
+    readonly callId: Schema.String;
+    readonly identity: Schema.Struct<{
+        /** Public logical run identity, not an authentication session credential. */
+        readonly runId: Schema.String;
+        readonly frame: Schema.Int;
+        readonly cell: Schema.String;
+        readonly ordinal: Schema.Int;
+        readonly declaration: Schema.String;
+        readonly layers: Schema.$Array<Schema.String>;
+    }>;
+    readonly flowName: Schema.String;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    /**
+     * The resolved declaration's display projection, as its owner encoded it.
+     *
+     * JSON rather than a struct because the vocabulary belongs to
+     * `@smthrs/registry` (`Descriptor.FlowActivity`, `Descriptor.CallPresentation`),
+     * which sits above this package: `@smthrs/harness` `Cell.displayDescriptor`
+     * encodes it from a typed call and the reading card validates each field
+     * before it is displayed, so the journal carries it and claims nothing about
+     * it. Absent means the declaration claimed nothing.
+     */
+    readonly descriptor: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+/** Decoded authorized call coordinates.
+ * @category models
+ * @since 1.0.0
+ */
+export type Call = typeof Call.Type;
+declare const Annotation_base: Context.ServiceClass<Annotation, "@smthrs/journal/CallFact/Annotation", {
+    readonly phase: "invoked" | "settled";
+    readonly call: Call;
+}>;
+/** Native action annotation; only the existing controller record settles a call.
+ * @category services
+ * @since 1.0.0
+ */
+export declare class Annotation extends Annotation_base {
+}
+/** Public result vocabulary. Executable outcomes remain in the protected attempt row.
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Result: Schema.Union<readonly [Schema.Struct<{
+    readonly outcome: Schema.Literal<"success">;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly message: Schema.optional<Schema.String>;
+    readonly code: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+    readonly outcome: Schema.Literal<"failure">;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly message: Schema.optional<Schema.String>;
+    readonly code: Schema.optional<Schema.String>;
+}>]>;
+/** Bounded, redacted event projection; a truncation marker is still JSON.
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Fact: Schema.Union<readonly [Schema.Struct<{
+    readonly phase: Schema.Literal<"invoked">;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly descriptor: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly version: Schema.Literal<1>;
+    readonly callId: Schema.String;
+    readonly identity: Schema.Struct<{
+        /** Public logical run identity, not an authentication session credential. */
+        readonly runId: Schema.String;
+        readonly frame: Schema.Int;
+        readonly cell: Schema.String;
+        readonly ordinal: Schema.Int;
+        readonly declaration: Schema.String;
+        readonly layers: Schema.$Array<Schema.String>;
+    }>;
+    readonly flowName: Schema.String;
+}>, Schema.Struct<{
+    readonly phase: Schema.Literal<"settled">;
+    readonly outcome: Schema.Literals<readonly ["success", "failure"]>;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly message: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly code: Schema.optional<Schema.String>;
+    readonly version: Schema.Literal<1>;
+    readonly callId: Schema.String;
+    readonly identity: Schema.Struct<{
+        /** Public logical run identity, not an authentication session credential. */
+        readonly runId: Schema.String;
+        readonly frame: Schema.Int;
+        readonly cell: Schema.String;
+        readonly ordinal: Schema.Int;
+        readonly declaration: Schema.String;
+        readonly layers: Schema.$Array<Schema.String>;
+    }>;
+    readonly flowName: Schema.String;
+}>]>;
+/** Decoded public native call fact.
+ * @category models
+ * @since 1.0.0
+ */
+export type Fact = typeof Fact.Type;
+/** The immutable native journal is the durable outbox consumed by the native bridge.
+ * @category events
+ * @since 1.0.0
+ */
+export declare const eventType = "flows.harness.call-fact.v1";
+export {};
+//# sourceMappingURL=CallFact.d.ts.map

package/dist/esm/CallFact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallFact.d.ts","sourceRoot":"","sources":["../../src/CallFact.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;GAGG;AACH,eAAO,MAAM,QAAQ;IACnB,6EAA6E;;;;;;;EAO7E,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,IAAI;;;QAbf,6EAA6E;;;;;;;;;;IAkB7E;;;;;;;;;OASG;;EAEH,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,CAAA;;oBAOjB,SAAS,GAAG,SAAS;mBACtB,IAAI;;AANrB;;;GAGG;AACH,qBAAa,UAAW,SAAQ,eAGW;CAAG;AAE9C;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;IAajB,CAAA;AASF;;;GAGG;AACH,eAAO,MAAM,IAAI;;;;;;;QA5Ef,6EAA6E;;;;;;;;;;;;;;;;;;QAA7E,6EAA6E;;;;;;;;;IA2F7E,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,SAAS,+BAA+B,CAAA"}