@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/internal/PlanMerges.js

@@ -0,0 +1,125 @@
+"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 PlanMerges_exports = {};
+__export(PlanMerges_exports, {
+  allocateId: () => allocateId,
+  draft: () => draft,
+  recover: () => recover,
+  validateIntent: () => validateIntent
+});
+module.exports = __toCommonJS(PlanMerges_exports);
+var import_plan = require("@smthrs/plan");
+var import_effect = require("effect");
+var PlanMergeStore = __toESM(require("../PlanMergeStore.js"), 1);
+const invalid = (message, cause) => new PlanMergeStore.PlanMergeError({
+  code: "corrupt_state",
+  message,
+  ...cause === void 0 ? {} : { cause }
+});
+const allocateId = (plan, nodeId) => {
+  const occupied = new Set(plan.nodes.map((node) => node.id));
+  const base = `${nodeId}+merge`;
+  let candidate = base;
+  for (let suffix = 1; occupied.has(candidate); suffix++) candidate = `${base}#${suffix}`;
+  return candidate;
+};
+const draft = (node, mergeId, winners) => ({
+  id: mergeId,
+  kind: "merge",
+  material: {
+    version: import_plan.KeyMaterial.version,
+    kind: node.material.kind,
+    body: { merge: { stopped: node.id, winners } },
+    inputs: winners.map((id) => ({ _tag: "Pending", from: id })),
+    layers: [],
+    capabilities: []
+  },
+  effects: node.effects
+});
+const validateIntent = (plan, intent) => import_effect.Effect.gen(function* () {
+  const node = plan.nodes.find((candidate) => candidate.id === intent.nodeId);
+  if (node === void 0 || node.key !== intent.nodeKey || node.material.kind === "irreversible" || node.runtime !== "stop-merge" && !node.conflicts.some((conflict) => conflict.runtime === "stop-merge") || intent.peers.some((id) => !node.conflicts.some((conflict) => conflict.with === id))) {
+    return yield* import_effect.Effect.fail(invalid("merge intent does not match its approved stopped node"));
+  }
+  return node;
+});
+const recover = (candidate, decisions) => import_effect.Effect.gen(function* () {
+  const byGeneration = new Map(
+    decisions.flatMap(
+      (decision) => decision.completion === void 0 ? [] : [[decision.completion.generation, decision]]
+    )
+  );
+  let plan = candidate;
+  if (byGeneration.size > 0) {
+    plan = yield* import_plan.Plan.verify({
+      ...candidate,
+      generation: 0,
+      digest: candidate.baseDigest,
+      nodes: candidate.nodes.filter((node) => node.generation === 0)
+    }).pipe(import_effect.Effect.mapError((cause) => invalid("merge recovery has an invalid approved base", cause)));
+    const last = Math.max(candidate.generation, ...byGeneration.keys());
+    if (last > import_plan.Plan.maximumPlanNodes) return yield* import_effect.Effect.fail(invalid("merge generation exceeds the plan limit"));
+    for (let generation = 1; generation <= last; generation++) {
+      const decision = byGeneration.get(generation);
+      let drafts;
+      if (decision?.completion !== void 0) {
+        const stopped = yield* validateIntent(plan, decision.intent);
+        if (decision.completion.parentDigest !== plan.digest) {
+          return yield* import_effect.Effect.fail(invalid("merge parent digest changed"));
+        }
+        drafts = [draft(stopped, decision.completion.mergeId, decision.completion.winners)];
+      } else {
+        drafts = candidate.nodes.filter((node) => node.generation === generation).map((node) => ({
+          id: node.id,
+          kind: node.kind,
+          material: node.material,
+          effects: node.effects,
+          priority: node.priority,
+          conflictStrategy: node.strategy,
+          runtimeStrategy: node.runtime
+        }));
+        if (drafts.length === 0) {
+          return yield* import_effect.Effect.fail(invalid("merge recovery requires the approved intervening plan generations"));
+        }
+      }
+      plan = yield* import_plan.Plan.append(plan, drafts).pipe(
+        import_effect.Effect.mapError((cause) => invalid("stored merge extension cannot be reconstructed", cause))
+      );
+      if (decision?.completion !== void 0 && (plan.digest !== decision.completion.planDigest || import_plan.Plan.generationNodes(plan)[0].key !== decision.completion.mergeKey)) {
+        return yield* import_effect.Effect.fail(invalid("merge decision does not identify its generated node"));
+      }
+      if (generation === candidate.generation && plan.digest !== candidate.digest) {
+        return yield* import_effect.Effect.fail(invalid("merge decisions disagree with the supplied plan"));
+      }
+    }
+  }
+  for (const decision of decisions) yield* validateIntent(plan, decision.intent);
+  return plan;
+});
+//# sourceMappingURL=PlanMerges.js.map

package/dist/cjs/internal/PlanMerges.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/PlanMerges.ts"],
+  "sourcesContent": ["/** Durable merge recovery and generated identity, independent of dispatch.\n * @since 1.0.0\n */\n\nimport { KeyMaterial, Plan } from \"@smthrs/plan\"\nimport { Effect } from \"effect\"\nimport * as PlanMergeStore from \"../PlanMergeStore.ts\"\n\nconst invalid = (message: string, cause?: unknown) =>\n  new PlanMergeStore.PlanMergeError({\n    code: \"corrupt_state\",\n    message,\n    ...(cause === undefined ? {} : { cause })\n  })\n/** Chooses a free display ID; ownership comes from the durable decision, not this spelling.\n * @since 1.0.0\n * @category identity\n */\nexport const allocateId = (plan: Plan.Plan, nodeId: string): string => {\n  const occupied = new Set(plan.nodes.map((node) => node.id))\n  const base = `${nodeId}+merge`\n  let candidate = base\n  for (let suffix = 1; occupied.has(candidate); suffix++) candidate = `${base}#${suffix}`\n  return candidate\n}\n/** The single declaration used both when appending and when recovering an extension.\n * @since 1.0.0\n * @category constructors\n */\nexport const draft = (node: Plan.PlanNode, mergeId: string, winners: ReadonlyArray<string>): Plan.NodeDraft => ({\n  id: mergeId,\n  kind: \"merge\",\n  material: {\n    version: KeyMaterial.version,\n    kind: node.material.kind,\n    body: { merge: { stopped: node.id, winners } },\n    inputs: winners.map((id) => ({ _tag: \"Pending\", from: id })),\n    layers: [],\n    capabilities: []\n  },\n  effects: node.effects\n})\n/** Checks that an intent names a permissible stopped node and its actual conflict peers.\n * @since 1.0.0\n * @category validation\n */\nexport const validateIntent = (plan: Plan.Plan, intent: PlanMergeStore.Intent) =>\n  Effect.gen(function*() {\n    const node = plan.nodes.find((candidate) => candidate.id === intent.nodeId)\n    if (\n      node === undefined || node.key !== intent.nodeKey || node.material.kind === \"irreversible\" ||\n      (node.runtime !== \"stop-merge\" && !node.conflicts.some((conflict) => conflict.runtime === \"stop-merge\")) ||\n      intent.peers.some((id) => !node.conflicts.some((conflict) => conflict.with === id))\n    ) {\n      return yield* Effect.fail(invalid(\"merge intent does not match its approved stopped node\"))\n    }\n    return node\n  })\n/** Recovers only recorded merge extensions, never unrelated/unapproved appended work.\n * @since 1.0.0\n * @category recovery\n */\nexport const recover = (candidate: Plan.Plan, decisions: ReadonlyArray<PlanMergeStore.Decision>) =>\n  Effect.gen(function*() {\n    const byGeneration = new Map(\n      decisions.flatMap((decision) =>\n        decision.completion === undefined ? [] : [[decision.completion.generation, decision] as const]\n      )\n    )\n    let plan = candidate\n    if (byGeneration.size > 0) {\n      // Rebuild each prefix once. Re-verifying every complete prefix separately\n      // would multiply the compiler's overlap work across a long merge history.\n      plan = yield* Plan.verify({\n        ...candidate,\n        generation: 0,\n        digest: candidate.baseDigest,\n        nodes: candidate.nodes.filter((node) => node.generation === 0)\n      })\n        .pipe(Effect.mapError((cause) => invalid(\"merge recovery has an invalid approved base\", cause)))\n      const last = Math.max(candidate.generation, ...byGeneration.keys())\n      if (last > Plan.maximumPlanNodes) return yield* Effect.fail(invalid(\"merge generation exceeds the plan limit\"))\n      for (let generation = 1; generation <= last; generation++) {\n        const decision = byGeneration.get(generation)\n        let drafts: ReadonlyArray<Plan.NodeDraft>\n        if (decision?.completion !== undefined) {\n          const stopped = yield* validateIntent(plan, decision.intent)\n          if (decision.completion.parentDigest !== plan.digest) {\n            return yield* Effect.fail(invalid(\"merge parent digest changed\"))\n          }\n          drafts = [draft(stopped, decision.completion.mergeId, decision.completion.winners)]\n        } else {\n          drafts = candidate.nodes.filter((node) => node.generation === generation).map((node) => ({\n            id: node.id,\n            kind: node.kind,\n            material: node.material,\n            effects: node.effects,\n            priority: node.priority,\n            conflictStrategy: node.strategy,\n            runtimeStrategy: node.runtime\n          }))\n          if (drafts.length === 0) {\n            return yield* Effect.fail(invalid(\"merge recovery requires the approved intervening plan generations\"))\n          }\n        }\n        plan = yield* Plan.append(plan, drafts).pipe(\n          Effect.mapError((cause) => invalid(\"stored merge extension cannot be reconstructed\", cause))\n        )\n        if (\n          decision?.completion !== undefined &&\n          (plan.digest !== decision.completion.planDigest ||\n            Plan.generationNodes(plan)[0]!.key !== decision.completion.mergeKey)\n        ) {\n          return yield* Effect.fail(invalid(\"merge decision does not identify its generated node\"))\n        }\n        if (generation === candidate.generation && plan.digest !== candidate.digest) {\n          return yield* Effect.fail(invalid(\"merge decisions disagree with the supplied plan\"))\n        }\n      }\n    }\n    for (const decision of decisions) yield* validateIntent(plan, decision.intent)\n    return plan\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,kBAAkC;AAClC,oBAAuB;AACvB,qBAAgC;AAEhC,MAAM,UAAU,CAAC,SAAiB,UAChC,IAAI,eAAe,eAAe;AAAA,EAChC,MAAM;AAAA,EACN;AAAA,EACA,GAAI,UAAU,SAAY,CAAC,IAAI,EAAE,MAAM;AACzC,CAAC;AAKI,MAAM,aAAa,CAAC,MAAiB,WAA2B;AACrE,QAAM,WAAW,IAAI,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,EAAE,CAAC;AAC1D,QAAM,OAAO,GAAG,MAAM;AACtB,MAAI,YAAY;AAChB,WAAS,SAAS,GAAG,SAAS,IAAI,SAAS,GAAG,SAAU,aAAY,GAAG,IAAI,IAAI,MAAM;AACrF,SAAO;AACT;AAKO,MAAM,QAAQ,CAAC,MAAqB,SAAiB,aAAoD;AAAA,EAC9G,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,UAAU;AAAA,IACR,SAAS,wBAAY;AAAA,IACrB,MAAM,KAAK,SAAS;AAAA,IACpB,MAAM,EAAE,OAAO,EAAE,SAAS,KAAK,IAAI,QAAQ,EAAE;AAAA,IAC7C,QAAQ,QAAQ,IAAI,CAAC,QAAQ,EAAE,MAAM,WAAW,MAAM,GAAG,EAAE;AAAA,IAC3D,QAAQ,CAAC;AAAA,IACT,cAAc,CAAC;AAAA,EACjB;AAAA,EACA,SAAS,KAAK;AAChB;AAKO,MAAM,iBAAiB,CAAC,MAAiB,WAC9C,qBAAO,IAAI,aAAY;AACrB,QAAM,OAAO,KAAK,MAAM,KAAK,CAAC,cAAc,UAAU,OAAO,OAAO,MAAM;AAC1E,MACE,SAAS,UAAa,KAAK,QAAQ,OAAO,WAAW,KAAK,SAAS,SAAS,kBAC3E,KAAK,YAAY,gBAAgB,CAAC,KAAK,UAAU,KAAK,CAAC,aAAa,SAAS,YAAY,YAAY,KACtG,OAAO,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,UAAU,KAAK,CAAC,aAAa,SAAS,SAAS,EAAE,CAAC,GAClF;AACA,WAAO,OAAO,qBAAO,KAAK,QAAQ,uDAAuD,CAAC;AAAA,EAC5F;AACA,SAAO;AACT,CAAC;AAKI,MAAM,UAAU,CAAC,WAAsB,cAC5C,qBAAO,IAAI,aAAY;AACrB,QAAM,eAAe,IAAI;AAAA,IACvB,UAAU;AAAA,MAAQ,CAAC,aACjB,SAAS,eAAe,SAAY,CAAC,IAAI,CAAC,CAAC,SAAS,WAAW,YAAY,QAAQ,CAAU;AAAA,IAC/F;AAAA,EACF;AACA,MAAI,OAAO;AACX,MAAI,aAAa,OAAO,GAAG;AAGzB,WAAO,OAAO,iBAAK,OAAO;AAAA,MACxB,GAAG;AAAA,MACH,YAAY;AAAA,MACZ,QAAQ,UAAU;AAAA,MAClB,OAAO,UAAU,MAAM,OAAO,CAAC,SAAS,KAAK,eAAe,CAAC;AAAA,IAC/D,CAAC,EACE,KAAK,qBAAO,SAAS,CAAC,UAAU,QAAQ,+CAA+C,KAAK,CAAC,CAAC;AACjG,UAAM,OAAO,KAAK,IAAI,UAAU,YAAY,GAAG,aAAa,KAAK,CAAC;AAClE,QAAI,OAAO,iBAAK,iBAAkB,QAAO,OAAO,qBAAO,KAAK,QAAQ,yCAAyC,CAAC;AAC9G,aAAS,aAAa,GAAG,cAAc,MAAM,cAAc;AACzD,YAAM,WAAW,aAAa,IAAI,UAAU;AAC5C,UAAI;AACJ,UAAI,UAAU,eAAe,QAAW;AACtC,cAAM,UAAU,OAAO,eAAe,MAAM,SAAS,MAAM;AAC3D,YAAI,SAAS,WAAW,iBAAiB,KAAK,QAAQ;AACpD,iBAAO,OAAO,qBAAO,KAAK,QAAQ,6BAA6B,CAAC;AAAA,QAClE;AACA,iBAAS,CAAC,MAAM,SAAS,SAAS,WAAW,SAAS,SAAS,WAAW,OAAO,CAAC;AAAA,MACpF,OAAO;AACL,iBAAS,UAAU,MAAM,OAAO,CAAC,SAAS,KAAK,eAAe,UAAU,EAAE,IAAI,CAAC,UAAU;AAAA,UACvF,IAAI,KAAK;AAAA,UACT,MAAM,KAAK;AAAA,UACX,UAAU,KAAK;AAAA,UACf,SAAS,KAAK;AAAA,UACd,UAAU,KAAK;AAAA,UACf,kBAAkB,KAAK;AAAA,UACvB,iBAAiB,KAAK;AAAA,QACxB,EAAE;AACF,YAAI,OAAO,WAAW,GAAG;AACvB,iBAAO,OAAO,qBAAO,KAAK,QAAQ,mEAAmE,CAAC;AAAA,QACxG;AAAA,MACF;AACA,aAAO,OAAO,iBAAK,OAAO,MAAM,MAAM,EAAE;AAAA,QACtC,qBAAO,SAAS,CAAC,UAAU,QAAQ,kDAAkD,KAAK,CAAC;AAAA,MAC7F;AACA,UACE,UAAU,eAAe,WACxB,KAAK,WAAW,SAAS,WAAW,cACnC,iBAAK,gBAAgB,IAAI,EAAE,CAAC,EAAG,QAAQ,SAAS,WAAW,WAC7D;AACA,eAAO,OAAO,qBAAO,KAAK,QAAQ,qDAAqD,CAAC;AAAA,MAC1F;AACA,UAAI,eAAe,UAAU,cAAc,KAAK,WAAW,UAAU,QAAQ;AAC3E,eAAO,OAAO,qBAAO,KAAK,QAAQ,iDAAiD,CAAC;AAAA,MACtF;AAAA,IACF;AAAA,EACF;AACA,aAAW,YAAY,UAAW,QAAO,eAAe,MAAM,SAAS,MAAM;AAC7E,SAAO;AACT,CAAC;",
+  "names": []
+}

package/dist/cjs/internal/ProvenanceSlot.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Read-only validation of the cache-provenance record occupying a producer
+ * slot this run re-emits into.
+ *
+ * A provenance producer identity (`cache:<digest>:<action>[:<run>:<seq>]`,
+ * `sourceSeq` 0) names ONE fact about one cache row — this key expired, this
+ * row was served, this replay failed — so a re-emission after a resume or in
+ * a fork child records the same fact with fresh measurements (`ageMs`, the
+ * clock, a later `reason`) and collapses onto the row already there. That
+ * collapse is legitimate only while the occupying record IS that fact: the
+ * same event type, the same key, the same action, and the same recorded row
+ * when the record names one. Anything else in the slot is the conflict the
+ * journal reported.
+ * @since 1.0.0-rc.0
+ */
+import type { Journal, JournalEvent } from "@smthrs/journal";
+import * as Effect from "effect/Effect";
+/**
+ * Accepts the occupying record only when it states the same provenance fact
+ * as `record`; otherwise fails with `conflict`.
+ * @category accessors
+ * @since 1.0.0-rc.0
+ */
+export declare const accept: (options: {
+    readonly journal: Journal.Service;
+    readonly runId: string;
+    readonly record: JournalEvent.Input;
+    readonly conflict: Journal.JournalError;
+}) => Effect.Effect<void, Journal.JournalError>;
+//# sourceMappingURL=ProvenanceSlot.d.ts.map

package/dist/cjs/internal/ProvenanceSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvenanceSlot.d.ts","sourceRoot":"","sources":["../../../src/internal/ProvenanceSlot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAQvC;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,KAAK,CAAA;IACnC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAA;CACxC,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAexC,CAAA"}

package/dist/cjs/internal/ProvenanceSlot.js

@@ -0,0 +1,53 @@
+"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 ProvenanceSlot_exports = {};
+__export(ProvenanceSlot_exports, {
+  accept: () => accept
+});
+module.exports = __toCommonJS(ProvenanceSlot_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var CacheAgeHistory = __toESM(require("./CacheAgeHistory.js"), 1);
+const identity = ["keyDigest", "action", "recordedRunId", "recordedEventSeq"];
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const accept = (options) => Effect.gen(function* () {
+  const { conflict, journal, record } = options;
+  const sourceSeq = record.sourceSeq ?? 0;
+  const entry = yield* CacheAgeHistory.find(
+    journal,
+    options.runId,
+    (candidate) => candidate.sourceId === record.sourceId && Number(candidate.sourceSeq) === Number(sourceSeq)
+  );
+  if (entry === void 0 || entry.eventType !== record.eventType) return yield* Effect.fail(conflict);
+  const attempted = record.payload;
+  const occupying = entry.payload;
+  if (!isRecord(attempted) || !isRecord(occupying)) return yield* Effect.fail(conflict);
+  const same = identity.every((field) => !(field in attempted) || attempted[field] === occupying[field]);
+  return same ? void 0 : yield* Effect.fail(conflict);
+});
+//# sourceMappingURL=ProvenanceSlot.js.map

package/dist/cjs/internal/ProvenanceSlot.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/ProvenanceSlot.ts"],
+  "sourcesContent": ["/**\n * Read-only validation of the cache-provenance record occupying a producer\n * slot this run re-emits into.\n *\n * A provenance producer identity (`cache:<digest>:<action>[:<run>:<seq>]`,\n * `sourceSeq` 0) names ONE fact about one cache row \u2014 this key expired, this\n * row was served, this replay failed \u2014 so a re-emission after a resume or in\n * a fork child records the same fact with fresh measurements (`ageMs`, the\n * clock, a later `reason`) and collapses onto the row already there. That\n * collapse is legitimate only while the occupying record IS that fact: the\n * same event type, the same key, the same action, and the same recorded row\n * when the record names one. Anything else in the slot is the conflict the\n * journal reported.\n * @since 1.0.0-rc.0\n */\n\nimport type { Journal, JournalEvent } from \"@smthrs/journal\"\nimport * as Effect from \"effect/Effect\"\nimport * as CacheAgeHistory from \"./CacheAgeHistory.ts\"\n\nconst identity = [\"keyDigest\", \"action\", \"recordedRunId\", \"recordedEventSeq\"] as const\n\nconst isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\n/**\n * Accepts the occupying record only when it states the same provenance fact\n * as `record`; otherwise fails with `conflict`.\n * @category accessors\n * @since 1.0.0-rc.0\n */\nexport const accept = (options: {\n  readonly journal: Journal.Service\n  readonly runId: string\n  readonly record: JournalEvent.Input\n  readonly conflict: Journal.JournalError\n}): Effect.Effect<void, Journal.JournalError> =>\n  Effect.gen(function*() {\n    const { conflict, journal, record } = options\n    const sourceSeq = record.sourceSeq ?? 0\n    const entry = yield* CacheAgeHistory.find(\n      journal,\n      options.runId,\n      (candidate) => candidate.sourceId === record.sourceId && Number(candidate.sourceSeq) === Number(sourceSeq)\n    )\n    if (entry === undefined || entry.eventType !== record.eventType) return yield* Effect.fail(conflict)\n    const attempted = record.payload\n    const occupying = entry.payload\n    if (!isRecord(attempted) || !isRecord(occupying)) return yield* Effect.fail(conflict)\n    const same = identity.every((field) => !(field in attempted) || attempted[field] === occupying[field])\n    return same ? undefined : yield* Effect.fail(conflict)\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,aAAwB;AACxB,sBAAiC;AAEjC,MAAM,WAAW,CAAC,aAAa,UAAU,iBAAiB,kBAAkB;AAE5E,MAAM,WAAW,CAAC,UAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAQ9D,MAAM,SAAS,CAAC,YAMrB,OAAO,IAAI,aAAY;AACrB,QAAM,EAAE,UAAU,SAAS,OAAO,IAAI;AACtC,QAAM,YAAY,OAAO,aAAa;AACtC,QAAM,QAAQ,OAAO,gBAAgB;AAAA,IACnC;AAAA,IACA,QAAQ;AAAA,IACR,CAAC,cAAc,UAAU,aAAa,OAAO,YAAY,OAAO,UAAU,SAAS,MAAM,OAAO,SAAS;AAAA,EAC3G;AACA,MAAI,UAAU,UAAa,MAAM,cAAc,OAAO,UAAW,QAAO,OAAO,OAAO,KAAK,QAAQ;AACnG,QAAM,YAAY,OAAO;AACzB,QAAM,YAAY,MAAM;AACxB,MAAI,CAAC,SAAS,SAAS,KAAK,CAAC,SAAS,SAAS,EAAG,QAAO,OAAO,OAAO,KAAK,QAAQ;AACpF,QAAM,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,SAAS,cAAc,UAAU,KAAK,MAAM,UAAU,KAAK,CAAC;AACrG,SAAO,OAAO,SAAY,OAAO,OAAO,KAAK,QAAQ;AACvD,CAAC;",
+  "names": []
+}

package/dist/cjs/internal/ResultEnvelope.d.ts

@@ -0,0 +1,88 @@
+/**
+ * A typed JSON settlement at the engine persistence boundary. The existing
+ * terminal fallback remains the encoder, so a rejected class cannot leave a
+ * run live. This module does not change existing result bytes or writers.
+ *
+ * @since 1.0.0
+ */
+import type { Flow } from "@smthrs/flow";
+import * as EngineEvent from "@smthrs/journal/EngineEvent";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+/**
+ * Encoded success or a classified failure.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const ResultEnvelope: Schema.Union<readonly [Schema.TaggedStruct<"Success", {
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.TaggedStruct<"Failure", {
+    readonly reason: Schema.Literals<readonly ["error", "defect", "interrupted", "encoding"]>;
+    readonly detail: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>;
+/**
+ * Encoded success or a classified failure.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type ResultEnvelope = EngineEvent.ResultEnvelope;
+/**
+ * Validate untrusted encoded state without dropping contradictory fields.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decode: (input: unknown) => Effect.Effect<{
+    readonly _tag: "Success";
+    readonly value: Schema.Json;
+} | {
+    readonly _tag: "Failure";
+    readonly reason: "error" | "encoding" | "defect" | "interrupted";
+    readonly detail: Schema.Json;
+}, EngineEvent.EventError, never>;
+/**
+ * The encoded settlement and whether the existing encoder required terminal
+ * fallback. Encoded domain failure is still an Encoded settlement; callers
+ * read its exit, never infer domain success from this discriminant.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Settlement: Schema.Union<readonly [Schema.TaggedStruct<"Encoded", {
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.TaggedStruct<"EncodingFailure", {
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly note: Schema.String;
+}>]>;
+/**
+ * Encoded terminal settlement and its encoding-failure status.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Settlement = typeof Settlement.Type;
+/**
+ * Admit an encoded settlement without introducing an error channel on the
+ * terminal write path. A corrupt codec output becomes a terminal failure.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const fromEncoded: (encoded: unknown, note?: string) => Effect.Effect<Settlement>;
+/**
+ * Wrap the established no-fail terminal encoder without changing its bytes.
+ *
+ * @category conversions
+ * @since 1.0.0
+ */
+export declare const encode: (flow: Flow.Any, result: Flow.Result<unknown, unknown>) => Effect.Effect<{
+    readonly _tag: "Encoded";
+    readonly value: Schema.Json;
+} | {
+    readonly _tag: "EncodingFailure";
+    readonly value: Schema.Json;
+    readonly note: string;
+}, never, never>;
+//# sourceMappingURL=ResultEnvelope.d.ts.map

package/dist/cjs/internal/ResultEnvelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResultEnvelope.d.ts","sourceRoot":"","sources":["../../../src/internal/ResultEnvelope.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,KAAK,WAAW,MAAM,6BAA6B,CAAA;AAE1D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;IAA6B,CAAA;AACxD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,cAAc,CAAA;AACvD;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO;;;;;;;iCAWlC,CAAA;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;;IAGrB,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,OAAO,EAAE,OAAO,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CA+BnF,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,MAAM,IAAI,CAAC,GAAG,EAAE,QAAQ,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;;;;;;;gBAGzE,CAAA"}

package/dist/cjs/internal/ResultEnvelope.js

@@ -0,0 +1,90 @@
+"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 ResultEnvelope_exports = {};
+__export(ResultEnvelope_exports, {
+  ResultEnvelope: () => ResultEnvelope,
+  Settlement: () => Settlement,
+  decode: () => decode,
+  encode: () => encode,
+  fromEncoded: () => fromEncoded
+});
+module.exports = __toCommonJS(ResultEnvelope_exports);
+var EngineEvent = __toESM(require("@smthrs/journal/EngineEvent"), 1);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var ExitEncoding = __toESM(require("./ExitEncoding.js"), 1);
+const ResultEnvelope = EngineEvent.ResultEnvelope;
+const decode = (input) => Effect.suspend(() => Schema.decodeUnknownEffect(ResultEnvelope, { onExcessProperty: "error" })(input)).pipe(
+  Effect.catchCause(
+    (cause) => Effect.fail(
+      new EngineEvent.EventError({
+        code: "malformed",
+        message: "invalid result envelope",
+        cause: Cause.squash(cause)
+      })
+    )
+  )
+);
+const Settlement = Schema.Union([
+  Schema.TaggedStruct("Encoded", { value: Schema.Json }),
+  Schema.TaggedStruct("EncodingFailure", { value: Schema.Json, note: Schema.String })
+]);
+const fromEncoded = (encoded, note) => Effect.suspend(() => Schema.decodeUnknownEffect(Schema.Json)(encoded)).pipe(
+  Effect.map(
+    (value) => note === void 0 ? { _tag: "Encoded", value } : { _tag: "EncodingFailure", value, note }
+  ),
+  Effect.catchCause((_cause) => {
+    const note2 = "the encoded settlement was not JSON";
+    return Effect.as(Effect.logWarning(`${note2}; preserving a terminal failure`), {
+      _tag: "EncodingFailure",
+      note: note2,
+      value: {
+        _tag: "Complete",
+        exit: {
+          _tag: "Failure",
+          cause: [{
+            _tag: "Die",
+            defect: {
+              _tag: ExitEncoding.projectionTag,
+              result: "Complete",
+              note: note2,
+              reasons: [],
+              value: null
+            }
+          }]
+        }
+      }
+    });
+  })
+);
+const encode = (flow, result) => ExitEncoding.encode(flow, result).pipe(
+  Effect.flatMap(({ encoded, note }) => fromEncoded(encoded, note))
+);
+//# sourceMappingURL=ResultEnvelope.js.map

package/dist/cjs/internal/ResultEnvelope.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/ResultEnvelope.ts"],
+  "sourcesContent": ["/**\n * A typed JSON settlement at the engine persistence boundary. The existing\n * terminal fallback remains the encoder, so a rejected class cannot leave a\n * run live. This module does not change existing result bytes or writers.\n *\n * @since 1.0.0\n */\n\nimport type { Flow } from \"@smthrs/flow\"\nimport * as EngineEvent from \"@smthrs/journal/EngineEvent\"\nimport * as Cause from \"effect/Cause\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as ExitEncoding from \"./ExitEncoding.ts\"\n\n/**\n * Encoded success or a classified failure.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const ResultEnvelope = EngineEvent.ResultEnvelope\n/**\n * Encoded success or a classified failure.\n *\n * @category models\n * @since 1.0.0\n */\nexport type ResultEnvelope = EngineEvent.ResultEnvelope\n/**\n * Validate untrusted encoded state without dropping contradictory fields.\n *\n * @category decoders\n * @since 1.0.0\n */\nexport const decode = (input: unknown) =>\n  Effect.suspend(() => Schema.decodeUnknownEffect(ResultEnvelope, { onExcessProperty: \"error\" })(input)).pipe(\n    Effect.catchCause((cause) =>\n      Effect.fail(\n        new EngineEvent.EventError({\n          code: \"malformed\",\n          message: \"invalid result envelope\",\n          cause: Cause.squash(cause)\n        })\n      )\n    )\n  )\n\n/**\n * The encoded settlement and whether the existing encoder required terminal\n * fallback. Encoded domain failure is still an Encoded settlement; callers\n * read its exit, never infer domain success from this discriminant.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Settlement = Schema.Union([\n  Schema.TaggedStruct(\"Encoded\", { value: Schema.Json }),\n  Schema.TaggedStruct(\"EncodingFailure\", { value: Schema.Json, note: Schema.String })\n])\n/**\n * Encoded terminal settlement and its encoding-failure status.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Settlement = typeof Settlement.Type\n\n/**\n * Admit an encoded settlement without introducing an error channel on the\n * terminal write path. A corrupt codec output becomes a terminal failure.\n *\n * @category decoders\n * @since 1.0.0\n */\nexport const fromEncoded = (encoded: unknown, note?: string): Effect.Effect<Settlement> =>\n  Effect.suspend(() => Schema.decodeUnknownEffect(Schema.Json)(encoded)).pipe(\n    Effect.map((value): Settlement =>\n      note === undefined ? { _tag: \"Encoded\", value } : { _tag: \"EncodingFailure\", value, note }\n    ),\n    Effect.catchCause((_cause) => {\n      const note = \"the encoded settlement was not JSON\"\n      // This is the same terminal-only policy as ExitEncoding.encode: record\n      // a failed settlement even when pure codec validation defects. No I/O\n      // or authority decision is retried by recovering this validation cause.\n      return Effect.as(Effect.logWarning(`${note}; preserving a terminal failure`), {\n        _tag: \"EncodingFailure\" as const,\n        note,\n        value: {\n          _tag: \"Complete\",\n          exit: {\n            _tag: \"Failure\",\n            cause: [{\n              _tag: \"Die\",\n              defect: {\n                _tag: ExitEncoding.projectionTag,\n                result: \"Complete\",\n                note,\n                reasons: [],\n                value: null\n              }\n            }]\n          }\n        }\n      })\n    })\n  )\n\n/**\n * Wrap the established no-fail terminal encoder without changing its bytes.\n *\n * @category conversions\n * @since 1.0.0\n */\nexport const encode = (flow: Flow.Any, result: Flow.Result<unknown, unknown>) =>\n  ExitEncoding.encode(flow, result).pipe(\n    Effect.flatMap(({ encoded, note }) => fromEncoded(encoded, note))\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,kBAA6B;AAC7B,YAAuB;AACvB,aAAwB;AACxB,aAAwB;AACxB,mBAA8B;AAQvB,MAAM,iBAAiB,YAAY;AAcnC,MAAM,SAAS,CAAC,UACrB,OAAO,QAAQ,MAAM,OAAO,oBAAoB,gBAAgB,EAAE,kBAAkB,QAAQ,CAAC,EAAE,KAAK,CAAC,EAAE;AAAA,EACrG,OAAO;AAAA,IAAW,CAAC,UACjB,OAAO;AAAA,MACL,IAAI,YAAY,WAAW;AAAA,QACzB,MAAM;AAAA,QACN,SAAS;AAAA,QACT,OAAO,MAAM,OAAO,KAAK;AAAA,MAC3B,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAUK,MAAM,aAAa,OAAO,MAAM;AAAA,EACrC,OAAO,aAAa,WAAW,EAAE,OAAO,OAAO,KAAK,CAAC;AAAA,EACrD,OAAO,aAAa,mBAAmB,EAAE,OAAO,OAAO,MAAM,MAAM,OAAO,OAAO,CAAC;AACpF,CAAC;AAgBM,MAAM,cAAc,CAAC,SAAkB,SAC5C,OAAO,QAAQ,MAAM,OAAO,oBAAoB,OAAO,IAAI,EAAE,OAAO,CAAC,EAAE;AAAA,EACrE,OAAO;AAAA,IAAI,CAAC,UACV,SAAS,SAAY,EAAE,MAAM,WAAW,MAAM,IAAI,EAAE,MAAM,mBAAmB,OAAO,KAAK;AAAA,EAC3F;AAAA,EACA,OAAO,WAAW,CAAC,WAAW;AAC5B,UAAMA,QAAO;AAIb,WAAO,OAAO,GAAG,OAAO,WAAW,GAAGA,KAAI,iCAAiC,GAAG;AAAA,MAC5E,MAAM;AAAA,MACN,MAAAA;AAAA,MACA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,MAAM;AAAA,UACJ,MAAM;AAAA,UACN,OAAO,CAAC;AAAA,YACN,MAAM;AAAA,YACN,QAAQ;AAAA,cACN,MAAM,aAAa;AAAA,cACnB,QAAQ;AAAA,cACR,MAAAA;AAAA,cACA,SAAS,CAAC;AAAA,cACV,OAAO;AAAA,YACT;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;AAQK,MAAM,SAAS,CAAC,MAAgB,WACrC,aAAa,OAAO,MAAM,MAAM,EAAE;AAAA,EAChC,OAAO,QAAQ,CAAC,EAAE,SAAS,KAAK,MAAM,YAAY,SAAS,IAAI,CAAC;AAClE;",
+  "names": ["note"]
+}