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

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

@@ -0,0 +1,97 @@
+/**
+ * The two-tier step-cache protocol, extracted out of `ActionPersistence`.
+ *
+ * `CacheAdmission` classifies the evidence that permits publication;
+ * `ActionPersistence` supplies the measured facts and durable ordering. This module owns *how* it becomes
+ * shareable and how a shared hit is made replayable, which is the half a
+ * two-tier composition has to be able to inject into:
+ *
+ * - {@link publishArtifacts} runs before the cache entry is written, so an
+ *   entry is never observable while an artifact it references is missing
+ *   (`reference/bazel/.../remote/UploadManifest.java:630-633`).
+ * - {@link publishEntry} runs after the transaction that made the local row
+ *   durable, so the shared entry lands last of all — and outside the write
+ *   transaction.
+ * - {@link hydrateArtifacts} runs after a replay refused for a *missing*
+ *   artifact — the one refusal a shared tier can repair — so the replay is
+ *   retried once against fetched bytes instead of falling straight through to
+ *   a real execution.
+ *
+ * The seams are `ArtifactSync` and `CacheSync`, both resolved optionally: a
+ * composition with no shared tier gets the `makeLocal()` implementations, whose
+ * publish steps are no-ops and whose `hydrate` reports nothing was fetched.
+ * That is why a purely local engine pays nothing for this file.
+ *
+ * Every host call here stays OUTSIDE the `DurableWriter` transaction, like the
+ * Jj snapshot and the boundary prepare/settle: a host call must never be held
+ * across a write transaction.
+ *
+ * Neither publication step can fail a run. A shared cache is an accelerator,
+ * and by the time these run the result is already durably recorded on this
+ * host — failing a completed run because an optional tier is unreachable trades
+ * a real result for an unavailable one. Both report the refusal instead, and
+ * the caller journals it, exactly as an unverified read set is journaled rather
+ * than swallowed.
+ *
+ * @since 0.1.0
+ */
+import type { CacheStore } from "@smthrs/step-cache";
+import * as Cause from "effect/Cause";
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as StepBoundary from "../StepBoundary.ts";
+/**
+ * Why a recorded result could not be shared, when it could not be.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Unshareable {
+    /** Which half of the two-tier publication refused. */
+    readonly stage: "artifacts" | "entry";
+    readonly message: string;
+}
+/**
+ * Makes every artifact the evidence references durable in the shared tier,
+ * reporting a refusal rather than failing.
+ *
+ * Called immediately before the transaction that records the cache entry, and
+ * never inside it. A refusal means the entry must not be published to the
+ * shared tier — the whole point of the ordering constraint — but says nothing
+ * about the *local* row, which stays as valid as it ever was.
+ *
+ * @since 0.1.0
+ * @category protocol
+ */
+export declare const publishArtifacts: (evidence: StepBoundary.BoundaryEvidence | undefined) => Effect.Effect<Unshareable | undefined, never, Crypto.Crypto>;
+/**
+ * Publishes the recorded entry to the shared step-result tier, reporting a
+ * refusal rather than failing.
+ *
+ * Called only after {@link publishArtifacts} reported success and only after
+ * the transaction that made the local row durable has committed: blobs first,
+ * entry last, and no network round trip held across a write transaction.
+ *
+ * @since 0.1.0
+ * @category protocol
+ */
+export declare const publishEntry: (entry: CacheStore.CacheEntry) => Effect.Effect<Unshareable | undefined>;
+/**
+ * Fetches the artifacts a replay could not resolve locally, reporting whether
+ * the replay is now worth retrying.
+ *
+ * @since 0.1.0
+ * @category protocol
+ */
+export declare const hydrateArtifacts: (evidence: StepBoundary.BoundaryEvidence) => Effect.Effect<boolean, never, Crypto.Crypto>;
+/**
+ * The classification a `replayOutputs` failure needs before it can be
+ * repaired: a {@link StepBoundary.MissingArtifact} means the bytes are simply
+ * not on this host, which a shared tier may fix. Anything else — a corrupt
+ * address, a host refusal — is not a fetchable condition.
+ *
+ * @since 0.1.0
+ * @category protocol
+ */
+export declare const replayMissingArtifact: (cause: Cause.Cause<unknown>) => StepBoundary.MissingArtifact | undefined;
+//# sourceMappingURL=CachePublication.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CachePublication.d.ts","sourceRoot":"","sources":["../../../src/internal/CachePublication.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,KAAK,YAAY,MAAM,oBAAoB,CAAA;AAclD;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAA;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,YAAY,CAAC,gBAAgB,GAAG,SAAS,KAClD,MAAM,CAAC,MAAM,CAAC,WAAW,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAU1D,CAAA;AAEJ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,UAAU,CAAC,UAAU,KAC3B,MAAM,CAAC,MAAM,CAAC,WAAW,GAAG,SAAS,CAKpC,CAAA;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,YAAY,CAAC,gBAAgB,KACtC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAM1C,CAAA;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,KAC1B,YAAY,CAAC,eAAe,GAAG,SAOjC,CAAA"}

package/dist/cjs/internal/CachePublication.js

@@ -0,0 +1,80 @@
+"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 CachePublication_exports = {};
+__export(CachePublication_exports, {
+  hydrateArtifacts: () => hydrateArtifacts,
+  publishArtifacts: () => publishArtifacts,
+  publishEntry: () => publishEntry,
+  replayMissingArtifact: () => replayMissingArtifact
+});
+module.exports = __toCommonJS(CachePublication_exports);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var ArtifactSync = __toESM(require("../ArtifactSync.js"), 1);
+var CacheSync = __toESM(require("../CacheSync.js"), 1);
+var StepBoundary = __toESM(require("../StepBoundary.js"), 1);
+const sync = Effect.map(
+  Effect.serviceOption(ArtifactSync.ArtifactSync),
+  (configured) => Option.isSome(configured) ? configured.value : ArtifactSync.makeLocal()
+);
+const entrySync = Effect.map(
+  Effect.serviceOption(CacheSync.CacheSync),
+  (configured) => Option.isSome(configured) ? configured.value : CacheSync.makeLocal()
+);
+const publishArtifacts = (evidence) => Effect.gen(function* () {
+  if (evidence === void 0) return void 0;
+  const digests = StepBoundary.referencedDigests(evidence);
+  if (digests.length === 0) return void 0;
+  const protocol = yield* sync;
+  return yield* protocol.publish(digests).pipe(
+    Effect.as(void 0),
+    Effect.catch((failure) => Effect.succeed({ stage: "artifacts", message: failure.message }))
+  );
+});
+const publishEntry = (entry) => Effect.gen(function* () {
+  const protocol = yield* entrySync;
+  const refused = yield* protocol.publishEntry(entry);
+  return Option.isSome(refused) ? { stage: "entry", message: refused.value.message } : void 0;
+});
+const hydrateArtifacts = (evidence) => Effect.gen(function* () {
+  const digests = StepBoundary.referencedDigests(evidence);
+  if (digests.length === 0) return false;
+  const protocol = yield* sync;
+  return yield* protocol.hydrate(digests);
+});
+const replayMissingArtifact = (cause) => {
+  for (const reason of cause.reasons) {
+    if (Cause.isFailReason(reason) && reason.error instanceof StepBoundary.MissingArtifact) {
+      return reason.error;
+    }
+  }
+  return void 0;
+};
+//# sourceMappingURL=CachePublication.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/CachePublication.ts"],
+  "sourcesContent": ["/**\n * The two-tier step-cache protocol, extracted out of `ActionPersistence`.\n *\n * `CacheAdmission` classifies the evidence that permits publication;\n * `ActionPersistence` supplies the measured facts and durable ordering. This module owns *how* it becomes\n * shareable and how a shared hit is made replayable, which is the half a\n * two-tier composition has to be able to inject into:\n *\n * - {@link publishArtifacts} runs before the cache entry is written, so an\n *   entry is never observable while an artifact it references is missing\n *   (`reference/bazel/.../remote/UploadManifest.java:630-633`).\n * - {@link publishEntry} runs after the transaction that made the local row\n *   durable, so the shared entry lands last of all \u2014 and outside the write\n *   transaction.\n * - {@link hydrateArtifacts} runs after a replay refused for a *missing*\n *   artifact \u2014 the one refusal a shared tier can repair \u2014 so the replay is\n *   retried once against fetched bytes instead of falling straight through to\n *   a real execution.\n *\n * The seams are `ArtifactSync` and `CacheSync`, both resolved optionally: a\n * composition with no shared tier gets the `makeLocal()` implementations, whose\n * publish steps are no-ops and whose `hydrate` reports nothing was fetched.\n * That is why a purely local engine pays nothing for this file.\n *\n * Every host call here stays OUTSIDE the `DurableWriter` transaction, like the\n * Jj snapshot and the boundary prepare/settle: a host call must never be held\n * across a write transaction.\n *\n * Neither publication step can fail a run. A shared cache is an accelerator,\n * and by the time these run the result is already durably recorded on this\n * host \u2014 failing a completed run because an optional tier is unreachable trades\n * a real result for an unavailable one. Both report the refusal instead, and\n * the caller journals it, exactly as an unverified read set is journaled rather\n * than swallowed.\n *\n * @since 0.1.0\n */\n\nimport type { CacheStore } from \"@smthrs/step-cache\"\nimport * as Cause from \"effect/Cause\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as ArtifactSync from \"../ArtifactSync.ts\"\nimport * as CacheSync from \"../CacheSync.ts\"\nimport * as StepBoundary from \"../StepBoundary.ts\"\n\n/** Resolves the configured protocol, defaulting to the single-tier one. */\nconst sync: Effect.Effect<ArtifactSync.Service> = Effect.map(\n  Effect.serviceOption(ArtifactSync.ArtifactSync),\n  (configured) => Option.isSome(configured) ? configured.value : ArtifactSync.makeLocal()\n)\n\n/** Resolves the configured entry publisher, defaulting to the single-tier one. */\nconst entrySync: Effect.Effect<CacheSync.Service> = Effect.map(\n  Effect.serviceOption(CacheSync.CacheSync),\n  (configured) => Option.isSome(configured) ? configured.value : CacheSync.makeLocal()\n)\n\n/**\n * Why a recorded result could not be shared, when it could not be.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Unshareable {\n  /** Which half of the two-tier publication refused. */\n  readonly stage: \"artifacts\" | \"entry\"\n  readonly message: string\n}\n\n/**\n * Makes every artifact the evidence references durable in the shared tier,\n * reporting a refusal rather than failing.\n *\n * Called immediately before the transaction that records the cache entry, and\n * never inside it. A refusal means the entry must not be published to the\n * shared tier \u2014 the whole point of the ordering constraint \u2014 but says nothing\n * about the *local* row, which stays as valid as it ever was.\n *\n * @since 0.1.0\n * @category protocol\n */\nexport const publishArtifacts = (\n  evidence: StepBoundary.BoundaryEvidence | undefined\n): Effect.Effect<Unshareable | undefined, never, Crypto.Crypto> =>\n  Effect.gen(function*() {\n    if (evidence === undefined) return undefined\n    const digests = StepBoundary.referencedDigests(evidence)\n    if (digests.length === 0) return undefined\n    const protocol = yield* sync\n    return yield* protocol.publish(digests).pipe(\n      Effect.as(undefined),\n      Effect.catch((failure) => Effect.succeed<Unshareable>({ stage: \"artifacts\", message: failure.message }))\n    )\n  })\n\n/**\n * Publishes the recorded entry to the shared step-result tier, reporting a\n * refusal rather than failing.\n *\n * Called only after {@link publishArtifacts} reported success and only after\n * the transaction that made the local row durable has committed: blobs first,\n * entry last, and no network round trip held across a write transaction.\n *\n * @since 0.1.0\n * @category protocol\n */\nexport const publishEntry = (\n  entry: CacheStore.CacheEntry\n): Effect.Effect<Unshareable | undefined> =>\n  Effect.gen(function*() {\n    const protocol = yield* entrySync\n    const refused = yield* protocol.publishEntry(entry)\n    return Option.isSome(refused) ? { stage: \"entry\" as const, message: refused.value.message } : undefined\n  })\n\n/**\n * Fetches the artifacts a replay could not resolve locally, reporting whether\n * the replay is now worth retrying.\n *\n * @since 0.1.0\n * @category protocol\n */\nexport const hydrateArtifacts = (\n  evidence: StepBoundary.BoundaryEvidence\n): Effect.Effect<boolean, never, Crypto.Crypto> =>\n  Effect.gen(function*() {\n    const digests = StepBoundary.referencedDigests(evidence)\n    if (digests.length === 0) return false\n    const protocol = yield* sync\n    return yield* protocol.hydrate(digests)\n  })\n\n/**\n * The classification a `replayOutputs` failure needs before it can be\n * repaired: a {@link StepBoundary.MissingArtifact} means the bytes are simply\n * not on this host, which a shared tier may fix. Anything else \u2014 a corrupt\n * address, a host refusal \u2014 is not a fetchable condition.\n *\n * @since 0.1.0\n * @category protocol\n */\nexport const replayMissingArtifact = (\n  cause: Cause.Cause<unknown>\n): StepBoundary.MissingArtifact | undefined => {\n  for (const reason of cause.reasons) {\n    if (Cause.isFailReason(reason) && reason.error instanceof StepBoundary.MissingArtifact) {\n      return reason.error\n    }\n  }\n  return undefined\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuCA,YAAuB;AAEvB,aAAwB;AACxB,aAAwB;AACxB,mBAA8B;AAC9B,gBAA2B;AAC3B,mBAA8B;AAG9B,MAAM,OAA4C,OAAO;AAAA,EACvD,OAAO,cAAc,aAAa,YAAY;AAAA,EAC9C,CAAC,eAAe,OAAO,OAAO,UAAU,IAAI,WAAW,QAAQ,aAAa,UAAU;AACxF;AAGA,MAAM,YAA8C,OAAO;AAAA,EACzD,OAAO,cAAc,UAAU,SAAS;AAAA,EACxC,CAAC,eAAe,OAAO,OAAO,UAAU,IAAI,WAAW,QAAQ,UAAU,UAAU;AACrF;AA0BO,MAAM,mBAAmB,CAC9B,aAEA,OAAO,IAAI,aAAY;AACrB,MAAI,aAAa,OAAW,QAAO;AACnC,QAAM,UAAU,aAAa,kBAAkB,QAAQ;AACvD,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,QAAM,WAAW,OAAO;AACxB,SAAO,OAAO,SAAS,QAAQ,OAAO,EAAE;AAAA,IACtC,OAAO,GAAG,MAAS;AAAA,IACnB,OAAO,MAAM,CAAC,YAAY,OAAO,QAAqB,EAAE,OAAO,aAAa,SAAS,QAAQ,QAAQ,CAAC,CAAC;AAAA,EACzG;AACF,CAAC;AAaI,MAAM,eAAe,CAC1B,UAEA,OAAO,IAAI,aAAY;AACrB,QAAM,WAAW,OAAO;AACxB,QAAM,UAAU,OAAO,SAAS,aAAa,KAAK;AAClD,SAAO,OAAO,OAAO,OAAO,IAAI,EAAE,OAAO,SAAkB,SAAS,QAAQ,MAAM,QAAQ,IAAI;AAChG,CAAC;AASI,MAAM,mBAAmB,CAC9B,aAEA,OAAO,IAAI,aAAY;AACrB,QAAM,UAAU,aAAa,kBAAkB,QAAQ;AACvD,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,QAAM,WAAW,OAAO;AACxB,SAAO,OAAO,SAAS,QAAQ,OAAO;AACxC,CAAC;AAWI,MAAM,wBAAwB,CACnC,UAC6C;AAC7C,aAAW,UAAU,MAAM,SAAS;AAClC,QAAI,MAAM,aAAa,MAAM,KAAK,OAAO,iBAAiB,aAAa,iBAAiB;AACtF,aAAO,OAAO;AAAA,IAChB;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": []
+}

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

@@ -0,0 +1,15 @@
+/** Native call facts written by the action owner, never a harness stream consumer.
+ * @since 1.0.0
+ */
+import { JournalEvent } from "@smthrs/journal";
+import * as Effect from "effect/Effect";
+/** No new action identity, callback, table or delivery queue is introduced.
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (action: unknown, runId: string) => {
+    settles: boolean;
+    invoked: Effect.Effect<JournalEvent.Input | undefined, never, import("effect/Crypto").Crypto>;
+    settled: (outcome: unknown) => Effect.Effect<JournalEvent.Input | undefined, never, import("effect/Crypto").Crypto>;
+};
+//# sourceMappingURL=CallFacts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CallFacts.d.ts","sourceRoot":"","sources":["../../../src/internal/CallFacts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAY,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAGxD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAgBvC;;;GAGG;AACH,eAAO,MAAM,IAAI,GAAI,QAAQ,OAAO,EAAE,OAAO,MAAM;;;uBAyD5B,OAAO;CAE7B,CAAA"}

package/dist/cjs/internal/CallFacts.js

@@ -0,0 +1,97 @@
+"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 CallFacts_exports = {};
+__export(CallFacts_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(CallFacts_exports);
+var import_journal = require("@smthrs/journal");
+var import_keys = require("@smthrs/keys");
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+const maxBytes = 65536;
+const encoder = new TextEncoder();
+const bounded = (value) => Effect.gen(function* () {
+  const bytes = encoder.encode(typeof value === "string" ? value : JSON.stringify(value)).byteLength;
+  return bytes <= maxBytes ? value : {
+    truncated: true,
+    bytes,
+    digest: (0, import_keys.digest)(yield* Schema.decodeUnknownEffect(import_keys.DerivedKey)(value).pipe(Effect.orDie))
+  };
+});
+const make = (action, runId) => {
+  const annotations = typeof action === "object" && action !== null && "annotations" in action ? action.annotations : void 0;
+  const annotation = annotations === void 0 ? Option.none() : Context.getOption(annotations, import_journal.CallFact.Annotation);
+  const resultSchema = typeof action === "object" && action !== null && "successSchema" in action && Schema.isSchema(action.successSchema) ? action.successSchema : void 0;
+  const record = (phase, outcome) => Effect.gen(function* () {
+    if (Option.isNone(annotation) || annotation.value.phase !== phase) return void 0;
+    const call = yield* Schema.decodeUnknownEffect(import_journal.CallFact.Call)(annotation.value.call).pipe(Effect.orDie);
+    if (phase === "settled" && resultSchema !== void 0) {
+      yield* Schema.decodeUnknownEffect(Schema.toCodecJson(resultSchema))(outcome).pipe(Effect.orDie);
+    }
+    const result = phase === "settled" ? yield* Schema.decodeUnknownEffect(import_journal.CallFact.Result)(outcome).pipe(Effect.orDie) : void 0;
+    const coordinates = {
+      version: 1,
+      callId: call.callId,
+      identity: call.identity,
+      flowName: call.flowName
+    };
+    const payload = result === void 0 ? {
+      ...coordinates,
+      phase: "invoked",
+      input: yield* bounded(call.input),
+      // Never bounded: the display projection is four short fields its
+      // owner already validated, and a truncation marker in its place
+      // would read as a declaration that claimed something unreadable.
+      ...call.descriptor === void 0 ? {} : { descriptor: call.descriptor }
+    } : {
+      ...coordinates,
+      phase: "settled",
+      outcome: result.outcome,
+      value: yield* bounded(result.value),
+      ...result.message === void 0 ? {} : { message: yield* bounded(result.message) },
+      ...result.code === void 0 ? {} : { code: result.code }
+    };
+    return new import_journal.JournalEvent.Input({
+      runId: import_journal.JournalEvent.RunId.make(runId),
+      sourceId: import_journal.JournalEvent.SourceId.make(`call-fact-v1:${call.callId}:${phase}`),
+      sourceSeq: import_journal.JournalEvent.SourceSeq.make(0),
+      eventType: import_journal.CallFact.eventType,
+      payload
+    });
+  });
+  return {
+    settles: Option.isSome(annotation) && annotation.value.phase === "settled",
+    invoked: record("invoked"),
+    settled: (outcome) => record("settled", outcome)
+  };
+};
+//# sourceMappingURL=CallFacts.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/CallFacts.ts"],
+  "sourcesContent": ["/** Native call facts written by the action owner, never a harness stream consumer.\n * @since 1.0.0\n */\n\nimport { CallFact, JournalEvent } from \"@smthrs/journal\"\nimport { DerivedKey, digest } from \"@smthrs/keys\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\n\nconst maxBytes = 65_536\nconst encoder = new TextEncoder()\nconst bounded = (value: Schema.Json) =>\n  Effect.gen(function*() {\n    const bytes = encoder.encode(typeof value === \"string\" ? value : JSON.stringify(value)).byteLength\n    return bytes <= maxBytes ? value : {\n      truncated: true,\n      bytes,\n      digest: digest(yield* Schema.decodeUnknownEffect(DerivedKey)(value).pipe(Effect.orDie))\n    }\n  })\n\n/** No new action identity, callback, table or delivery queue is introduced.\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (action: unknown, runId: string) => {\n  const annotations = typeof action === \"object\" && action !== null && \"annotations\" in action\n    ? action.annotations as Context.Context<never>\n    : undefined\n  const annotation = annotations === undefined ? Option.none() : Context.getOption(annotations, CallFact.Annotation)\n  const resultSchema =\n    typeof action === \"object\" && action !== null && \"successSchema\" in action && Schema.isSchema(action.successSchema)\n      ? action.successSchema as Schema.Codec<unknown, unknown>\n      : undefined\n  const record = (phase: \"invoked\" | \"settled\", outcome?: unknown) =>\n    Effect.gen(function*() {\n      if (Option.isNone(annotation) || annotation.value.phase !== phase) return undefined\n      const call = yield* Schema.decodeUnknownEffect(CallFact.Call)(annotation.value.call).pipe(Effect.orDie)\n      // Production record boundaries carry a service-free success codec. Check\n      // it before publishing an older encoded row as a deliverable result: the\n      // reader would refuse a corrupt row even when its broad JSON shape fits.\n      if (phase === \"settled\" && resultSchema !== undefined) {\n        yield* Schema.decodeUnknownEffect(Schema.toCodecJson(resultSchema))(outcome).pipe(Effect.orDie)\n      }\n      const result = phase === \"settled\"\n        ? yield* Schema.decodeUnknownEffect(CallFact.Result)(outcome).pipe(Effect.orDie)\n        : undefined\n      const coordinates = {\n        version: 1 as const,\n        callId: call.callId,\n        identity: call.identity,\n        flowName: call.flowName\n      }\n      const payload: CallFact.Fact = result === undefined\n        ? {\n          ...coordinates,\n          phase: \"invoked\",\n          input: yield* bounded(call.input),\n          // Never bounded: the display projection is four short fields its\n          // owner already validated, and a truncation marker in its place\n          // would read as a declaration that claimed something unreadable.\n          ...(call.descriptor === undefined ? {} : { descriptor: call.descriptor })\n        }\n        : {\n          ...coordinates,\n          phase: \"settled\",\n          outcome: result.outcome,\n          value: yield* bounded(result.value),\n          ...(result.message === undefined ? {} : { message: yield* bounded(result.message) }),\n          ...(result.code === undefined ? {} : { code: result.code })\n        }\n      return new JournalEvent.Input({\n        runId: JournalEvent.RunId.make(runId),\n        sourceId: JournalEvent.SourceId.make(`call-fact-v1:${call.callId}:${phase}`),\n        sourceSeq: JournalEvent.SourceSeq.make(0),\n        eventType: CallFact.eventType,\n        payload\n      })\n    })\n  return {\n    settles: Option.isSome(annotation) && annotation.value.phase === \"settled\",\n    invoked: record(\"invoked\"),\n    settled: (outcome: unknown) => record(\"settled\", outcome)\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,qBAAuC;AACvC,kBAAmC;AACnC,cAAyB;AACzB,aAAwB;AACxB,aAAwB;AACxB,aAAwB;AAExB,MAAM,WAAW;AACjB,MAAM,UAAU,IAAI,YAAY;AAChC,MAAM,UAAU,CAAC,UACf,OAAO,IAAI,aAAY;AACrB,QAAM,QAAQ,QAAQ,OAAO,OAAO,UAAU,WAAW,QAAQ,KAAK,UAAU,KAAK,CAAC,EAAE;AACxF,SAAO,SAAS,WAAW,QAAQ;AAAA,IACjC,WAAW;AAAA,IACX;AAAA,IACA,YAAQ,oBAAO,OAAO,OAAO,oBAAoB,sBAAU,EAAE,KAAK,EAAE,KAAK,OAAO,KAAK,CAAC;AAAA,EACxF;AACF,CAAC;AAMI,MAAM,OAAO,CAAC,QAAiB,UAAkB;AACtD,QAAM,cAAc,OAAO,WAAW,YAAY,WAAW,QAAQ,iBAAiB,SAClF,OAAO,cACP;AACJ,QAAM,aAAa,gBAAgB,SAAY,OAAO,KAAK,IAAI,QAAQ,UAAU,aAAa,wBAAS,UAAU;AACjH,QAAM,eACJ,OAAO,WAAW,YAAY,WAAW,QAAQ,mBAAmB,UAAU,OAAO,SAAS,OAAO,aAAa,IAC9G,OAAO,gBACP;AACN,QAAM,SAAS,CAAC,OAA8B,YAC5C,OAAO,IAAI,aAAY;AACrB,QAAI,OAAO,OAAO,UAAU,KAAK,WAAW,MAAM,UAAU,MAAO,QAAO;AAC1E,UAAM,OAAO,OAAO,OAAO,oBAAoB,wBAAS,IAAI,EAAE,WAAW,MAAM,IAAI,EAAE,KAAK,OAAO,KAAK;AAItG,QAAI,UAAU,aAAa,iBAAiB,QAAW;AACrD,aAAO,OAAO,oBAAoB,OAAO,YAAY,YAAY,CAAC,EAAE,OAAO,EAAE,KAAK,OAAO,KAAK;AAAA,IAChG;AACA,UAAM,SAAS,UAAU,YACrB,OAAO,OAAO,oBAAoB,wBAAS,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,KAAK,IAC7E;AACJ,UAAM,cAAc;AAAA,MAClB,SAAS;AAAA,MACT,QAAQ,KAAK;AAAA,MACb,UAAU,KAAK;AAAA,MACf,UAAU,KAAK;AAAA,IACjB;AACA,UAAM,UAAyB,WAAW,SACtC;AAAA,MACA,GAAG;AAAA,MACH,OAAO;AAAA,MACP,OAAO,OAAO,QAAQ,KAAK,KAAK;AAAA;AAAA;AAAA;AAAA,MAIhC,GAAI,KAAK,eAAe,SAAY,CAAC,IAAI,EAAE,YAAY,KAAK,WAAW;AAAA,IACzE,IACE;AAAA,MACA,GAAG;AAAA,MACH,OAAO;AAAA,MACP,SAAS,OAAO;AAAA,MAChB,OAAO,OAAO,QAAQ,OAAO,KAAK;AAAA,MAClC,GAAI,OAAO,YAAY,SAAY,CAAC,IAAI,EAAE,SAAS,OAAO,QAAQ,OAAO,OAAO,EAAE;AAAA,MAClF,GAAI,OAAO,SAAS,SAAY,CAAC,IAAI,EAAE,MAAM,OAAO,KAAK;AAAA,IAC3D;AACF,WAAO,IAAI,4BAAa,MAAM;AAAA,MAC5B,OAAO,4BAAa,MAAM,KAAK,KAAK;AAAA,MACpC,UAAU,4BAAa,SAAS,KAAK,gBAAgB,KAAK,MAAM,IAAI,KAAK,EAAE;AAAA,MAC3E,WAAW,4BAAa,UAAU,KAAK,CAAC;AAAA,MACxC,WAAW,wBAAS;AAAA,MACpB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH,SAAO;AAAA,IACL,SAAS,OAAO,OAAO,UAAU,KAAK,WAAW,MAAM,UAAU;AAAA,IACjE,SAAS,OAAO,SAAS;AAAA,IACzB,SAAS,CAAC,YAAqB,OAAO,WAAW,OAAO;AAAA,EAC1D;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Read-only validation of a journal record another lineage recorded under
+ * this run's producer identity.
+ *
+ * A time-travel fork copies the parent's journal rows verbatim: the copied
+ * record keeps the producer identity, but its payload names the parent run and
+ * its `meta.lineageId` is the parent's lineage, so this run's re-emission of
+ * the same record raises `idempotency_conflict` instead of collapsing into a
+ * `Duplicate`. That conflict is benign ONLY when the occupying record is the
+ * record being emitted, recorded by a validated ancestor. Anything else in the
+ * slot — an unrelated event type, another attempt's coordinates, the opposite
+ * terminal state, a record with no retained fork ancestry — is the conflict
+ * the journal reported, and it fails closed.
+ * @since 1.0.0-rc.0
+ */
+import { Journal, JournalEvent } from "@smthrs/journal";
+import type { RunStore } from "@smthrs/run-store";
+import * as Effect from "effect/Effect";
+/** Paged lookup retains only the matching record, including unexpected event types.
+ * @category accessors
+ * @since 1.0.0-rc.0
+ */
+export declare const find: (journal: Journal.Service, runId: string, predicate: (entry: JournalEvent.Entry) => boolean) => Effect.Effect<JournalEvent.Entry | undefined, Journal.JournalError>;
+/**
+ * Proves every retained fork prefix between a copied entry and its original.
+ * Callers retain their payload and metadata equality rules.
+ * @category accessors
+ * @since 1.0.0
+ */
+export declare const prove: (options: {
+    readonly journal: Journal.Service;
+    readonly runs: RunStore.Service;
+    readonly runId: string;
+    readonly entry: JournalEvent.Entry;
+    readonly conflict: Journal.JournalError;
+    readonly same?: (left: unknown, right: unknown) => boolean;
+}) => Effect.Effect<{
+    ancestor: string;
+    record: JournalEvent.Entry;
+}, Journal.JournalError, never>;
+/**
+ * Accepts the occupying record only when it is `record` as a validated
+ * copied-lineage ancestor emitted it; otherwise fails with `conflict`.
+ *
+ * The shared ancestry proof requires, at each hop, the child's fork marker above the copied prefix, the parent row the
+ * marker was cut at, and the parent's own copy of the record at the same
+ * `seq`, identical in content. The walk ends at the run whose lineage the
+ * record carries, and that run's original must be the record being emitted
+ * under that run's identity: same event type, same payload with the ancestor
+ * in place of this run, same meta.
+ * @category accessors
+ * @since 1.0.0-rc.0
+ */
+export declare const accept: (options: {
+    readonly journal: Journal.Service;
+    readonly runs: RunStore.Service;
+    readonly runId: string;
+    readonly record: JournalEvent.Input;
+    readonly conflict: Journal.JournalError;
+}) => Effect.Effect<void, Journal.JournalError>;
+//# sourceMappingURL=CopiedRecord.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CopiedRecord.d.ts","sourceRoot":"","sources":["../../../src/internal/CopiedRecord.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC;;;GAGG;AACH,eAAO,MAAM,IAAI,GACf,SAAS,OAAO,CAAC,OAAO,EACxB,OAAO,MAAM,EACb,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,KAAK,OAAO,KAChD,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,GAAG,SAAS,EAAE,OAAO,CAAC,YAAY,CAoBjE,CAAA;AAgBJ;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,SAAS;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAA;IAClC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAA;IACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;CAC3D;;;+BAqFG,CAAA;AAEJ;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;IACjC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAA;IAC/B,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,CAaxC,CAAA"}

package/dist/cjs/internal/CopiedRecord.js

@@ -0,0 +1,134 @@
+"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 CopiedRecord_exports = {};
+__export(CopiedRecord_exports, {
+  accept: () => accept,
+  find: () => find,
+  prove: () => prove
+});
+module.exports = __toCommonJS(CopiedRecord_exports);
+var import_canonical = require("@smthrs/canonical");
+var import_engine = require("@smthrs/engine");
+var import_journal = require("@smthrs/journal");
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_RunState = require("../RunState.js");
+const find = (journal, runId, predicate) => Effect.gen(function* () {
+  let after;
+  while (true) {
+    const page = yield* journal.entries({
+      runId: import_journal.JournalEvent.RunId.make(runId),
+      limit: 128,
+      ...after === void 0 ? {} : { after }
+    });
+    const entry = page.entries.find(predicate);
+    if (entry !== void 0) return entry;
+    if (!page.hasMore) return void 0;
+    const next = page.entries.at(-1)?.seq;
+    if (next === void 0 || after !== void 0 && next <= after) {
+      return yield* Effect.fail(
+        new import_journal.Journal.JournalError({ code: "read_failed", message: "cache history cursor did not advance" })
+      );
+    }
+    after = next;
+  }
+});
+const sameJson = (left, right) => left === void 0 || right === void 0 ? left === right : (0, import_canonical.canonicalize)(left, { loneSurrogates: "escape" }) === (0, import_canonical.canonicalize)(right, { loneSurrogates: "escape" });
+const asEmittedBy = (record, runId, ancestor) => ({
+  payload: (0, import_canonical.isRecord)(record.payload) && record.payload["runId"] === runId ? { ...record.payload, runId: ancestor } : record.payload,
+  meta: (0, import_canonical.isRecord)(record.meta) ? { ...record.meta, lineageId: import_engine.FlowEngine.Lineage.root(ancestor) } : record.meta
+});
+const prove = (options) => Effect.gen(function* () {
+  const { conflict, journal, runs, same = sameJson } = options;
+  let entry = options.entry;
+  const source = (candidate) => candidate.sourceId === options.entry.sourceId && candidate.sourceSeq === options.entry.sourceSeq;
+  let child = options.runId;
+  const visited = /* @__PURE__ */ new Set();
+  while (!visited.has(child)) {
+    visited.add(child);
+    const run = yield* runs.get(child).pipe(Effect.mapError(
+      (cause) => new import_journal.Journal.JournalError({
+        code: "idempotency_conflict",
+        message: conflict.message,
+        cause
+      })
+    ));
+    const parent = run.parentRunId;
+    if (parent === null) return yield* Effect.fail(conflict);
+    const copied = entry;
+    const marker = yield* find(journal, child, (candidate) => {
+      const value = candidate.payload;
+      return candidate.eventType === "flows.time-travel.fork-created" && candidate.sourceId === "flows/time-travel/fork" && Number(candidate.sourceSeq) === candidate.seq && value?.childRunId === child && value.parentRunId === parent && typeof value.forkJournalOffset === "number" && Number.isSafeInteger(value.forkJournalOffset) && value.forkJournalOffset >= copied.seq && candidate.seq === value.forkJournalOffset + 1 && (value.copiedFromRunId === void 0 || typeof value.copiedFromRunId === "string") && same(value, {
+        childRunId: child,
+        parentRunId: parent,
+        forkJournalOffset: value.forkJournalOffset,
+        ...value.copiedFromRunId === void 0 ? {} : { copiedFromRunId: value.copiedFromRunId }
+      });
+    });
+    if (marker === void 0) return yield* Effect.fail(conflict);
+    const copiedFrom = marker.payload.copiedFromRunId;
+    const sourceRunId = copiedFrom ?? parent;
+    if (copiedFrom !== void 0) {
+      const decodeState = Schema.decodeUnknownEffect(Schema.fromJsonString(import_RunState.RunState));
+      const state = yield* decodeState(run.stateJson).pipe(Effect.mapError(() => conflict));
+      const sourceRun = yield* runs.get(copiedFrom).pipe(Effect.mapError(() => conflict));
+      const sourceState = yield* decodeState(sourceRun.stateJson).pipe(Effect.mapError(() => conflict));
+      const parentRun = yield* runs.get(parent).pipe(Effect.mapError(() => conflict));
+      if (!state.forkKeyRunIds?.includes(copiedFrom) || state.parentExecutionId !== parent || sourceState.parentExecutionId === void 0 || parentRun.parentRunId !== sourceState.parentExecutionId) return yield* Effect.fail(conflict);
+      const parentFork = yield* find(journal, parent, (candidate) => {
+        const value = candidate.payload;
+        return candidate.eventType === "flows.time-travel.fork-created" && candidate.sourceId === "flows/time-travel/fork" && Number(candidate.sourceSeq) === candidate.seq && value?.childRunId === parent && value.parentRunId === sourceState.parentExecutionId;
+      });
+      if (parentFork === void 0) return yield* Effect.fail(conflict);
+    }
+    const cutoff = yield* find(journal, sourceRunId, (candidate) => candidate.seq === marker.seq - 1);
+    if (cutoff === void 0 || !same(marker.meta, { lineageId: cutoff.meta?.lineageId })) {
+      return yield* Effect.fail(conflict);
+    }
+    const original = yield* find(journal, sourceRunId, source);
+    if (original === void 0 || original.seq !== copied.seq || original.emittedAtMs !== copied.emittedAtMs || original.eventType !== copied.eventType || !same(original.payload, copied.payload) || !same(original.meta, copied.meta)) return yield* Effect.fail(conflict);
+    if ((0, import_canonical.isRecord)(original.meta) && original.meta["lineageId"] === import_engine.FlowEngine.Lineage.root(sourceRunId)) {
+      return { ancestor: sourceRunId, record: original };
+    }
+    child = sourceRunId;
+    entry = original;
+  }
+  return yield* Effect.fail(conflict);
+});
+const accept = (options) => Effect.gen(function* () {
+  const { conflict, journal, record } = options;
+  const sourceSeq = record.sourceSeq ?? 0;
+  const source = (entry2) => entry2.sourceId === record.sourceId && Number(entry2.sourceSeq) === Number(sourceSeq);
+  const entry = yield* find(journal, options.runId, source);
+  if (entry === void 0 || entry.eventType !== record.eventType) return yield* Effect.fail(conflict);
+  const original = yield* prove({ ...options, entry });
+  const expected = asEmittedBy(record, options.runId, original.ancestor);
+  return sameJson(original.record.payload, expected.payload) && sameJson(original.record.meta, expected.meta) ? void 0 : yield* Effect.fail(conflict);
+});
+//# sourceMappingURL=CopiedRecord.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/CopiedRecord.ts"],
+  "sourcesContent": ["/**\n * Read-only validation of a journal record another lineage recorded under\n * this run's producer identity.\n *\n * A time-travel fork copies the parent's journal rows verbatim: the copied\n * record keeps the producer identity, but its payload names the parent run and\n * its `meta.lineageId` is the parent's lineage, so this run's re-emission of\n * the same record raises `idempotency_conflict` instead of collapsing into a\n * `Duplicate`. That conflict is benign ONLY when the occupying record is the\n * record being emitted, recorded by a validated ancestor. Anything else in the\n * slot \u2014 an unrelated event type, another attempt's coordinates, the opposite\n * terminal state, a record with no retained fork ancestry \u2014 is the conflict\n * the journal reported, and it fails closed.\n * @since 1.0.0-rc.0\n */\n\nimport { canonicalize, isRecord } from \"@smthrs/canonical\"\nimport { FlowEngine } from \"@smthrs/engine\"\nimport { Journal, JournalEvent } from \"@smthrs/journal\"\nimport type { RunStore } from \"@smthrs/run-store\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport { RunState } from \"../RunState.ts\"\n\n/** Paged lookup retains only the matching record, including unexpected event types.\n * @category accessors\n * @since 1.0.0-rc.0\n */\nexport const find = (\n  journal: Journal.Service,\n  runId: string,\n  predicate: (entry: JournalEvent.Entry) => boolean\n): Effect.Effect<JournalEvent.Entry | undefined, Journal.JournalError> =>\n  Effect.gen(function*() {\n    let after: JournalEvent.Seq | undefined\n    while (true) {\n      const page = yield* journal.entries({\n        runId: JournalEvent.RunId.make(runId),\n        limit: 128,\n        ...after === undefined ? {} : { after }\n      })\n      const entry = page.entries.find(predicate)\n      if (entry !== undefined) return entry\n      if (!page.hasMore) return undefined\n      const next = page.entries.at(-1)?.seq\n      if (next === undefined || (after !== undefined && next <= after)) {\n        return yield* Effect.fail(\n          new Journal.JournalError({ code: \"read_failed\", message: \"cache history cursor did not advance\" })\n        )\n      }\n      after = next\n    }\n  })\n\nconst sameJson = (left: unknown, right: unknown): boolean =>\n  left === undefined || right === undefined\n    ? left === right\n    : canonicalize(left, { loneSurrogates: \"escape\" }) === canonicalize(right, { loneSurrogates: \"escape\" })\n\n/** The record as the named ancestor would have emitted it: the payload's own\n * `runId` and the lineage in `meta` name that run instead of this one. */\nconst asEmittedBy = (record: JournalEvent.Input, runId: string, ancestor: string) => ({\n  payload: isRecord(record.payload) && record.payload[\"runId\"] === runId\n    ? { ...record.payload, runId: ancestor }\n    : record.payload,\n  meta: isRecord(record.meta) ? { ...record.meta, lineageId: FlowEngine.Lineage.root(ancestor) } : record.meta\n})\n\n/**\n * Proves every retained fork prefix between a copied entry and its original.\n * Callers retain their payload and metadata equality rules.\n * @category accessors\n * @since 1.0.0\n */\nexport const prove = (options: {\n  readonly journal: Journal.Service\n  readonly runs: RunStore.Service\n  readonly runId: string\n  readonly entry: JournalEvent.Entry\n  readonly conflict: Journal.JournalError\n  readonly same?: (left: unknown, right: unknown) => boolean\n}) =>\n  Effect.gen(function*() {\n    const { conflict, journal, runs, same = sameJson } = options\n    let entry = options.entry\n    const source = (candidate: JournalEvent.Entry) =>\n      candidate.sourceId === options.entry.sourceId && candidate.sourceSeq === options.entry.sourceSeq\n    let child = options.runId\n    const visited = new Set<string>()\n    while (!visited.has(child)) {\n      visited.add(child)\n      const run = yield* runs.get(child).pipe(Effect.mapError((cause) =>\n        new Journal.JournalError({\n          code: \"idempotency_conflict\",\n          message: conflict.message,\n          cause\n        })\n      ))\n      const parent = run.parentRunId\n      if (parent === null) return yield* Effect.fail(conflict)\n      const copied = entry\n      const marker = yield* find(journal, child, (candidate) => {\n        const value = candidate.payload as {\n          readonly childRunId?: unknown\n          readonly parentRunId?: unknown\n          readonly forkJournalOffset?: unknown\n          readonly copiedFromRunId?: unknown\n        } | null\n        return candidate.eventType === \"flows.time-travel.fork-created\" &&\n          candidate.sourceId === \"flows/time-travel/fork\" && Number(candidate.sourceSeq) === candidate.seq &&\n          value?.childRunId === child &&\n          value.parentRunId === parent && typeof value.forkJournalOffset === \"number\" &&\n          Number.isSafeInteger(value.forkJournalOffset) && value.forkJournalOffset >= copied.seq &&\n          candidate.seq === value.forkJournalOffset + 1 &&\n          (value.copiedFromRunId === undefined || typeof value.copiedFromRunId === \"string\") &&\n          same(value, {\n            childRunId: child,\n            parentRunId: parent,\n            forkJournalOffset: value.forkJournalOffset,\n            ...(value.copiedFromRunId === undefined ? {} : { copiedFromRunId: value.copiedFromRunId })\n          })\n      })\n      if (marker === undefined) return yield* Effect.fail(conflict)\n      const copiedFrom = (marker.payload as { copiedFromRunId?: string }).copiedFromRunId\n      const sourceRunId = copiedFrom ?? parent\n      if (copiedFrom !== undefined) {\n        const decodeState = Schema.decodeUnknownEffect(Schema.fromJsonString(RunState))\n        const state = yield* decodeState(run.stateJson).pipe(Effect.mapError(() => conflict))\n        const sourceRun = yield* runs.get(copiedFrom).pipe(Effect.mapError(() => conflict))\n        const sourceState = yield* decodeState(sourceRun.stateJson).pipe(Effect.mapError(() => conflict))\n        const parentRun = yield* runs.get(parent).pipe(Effect.mapError(() => conflict))\n        if (\n          !state.forkKeyRunIds?.includes(copiedFrom) || state.parentExecutionId !== parent ||\n          sourceState.parentExecutionId === undefined || parentRun.parentRunId !== sourceState.parentExecutionId\n        ) return yield* Effect.fail(conflict)\n        // A carried origin must belong to the run the new parent forked.\n        // Its receipt alone never grants reuse of an unrelated run's records.\n        const parentFork = yield* find(journal, parent, (candidate) => {\n          const value = candidate.payload as { childRunId?: unknown; parentRunId?: unknown } | null\n          return candidate.eventType === \"flows.time-travel.fork-created\" &&\n            candidate.sourceId === \"flows/time-travel/fork\" &&\n            Number(candidate.sourceSeq) === candidate.seq &&\n            value?.childRunId === parent && value.parentRunId === sourceState.parentExecutionId\n        })\n        if (parentFork === undefined) return yield* Effect.fail(conflict)\n      }\n      const cutoff = yield* find(journal, sourceRunId, (candidate) => candidate.seq === marker.seq - 1)\n      if (\n        cutoff === undefined ||\n        !same(marker.meta, { lineageId: (cutoff.meta as { lineageId?: unknown } | null)?.lineageId })\n      ) {\n        return yield* Effect.fail(conflict)\n      }\n      const original = yield* find(journal, sourceRunId, source)\n      if (\n        original === undefined || original.seq !== copied.seq || original.emittedAtMs !== copied.emittedAtMs ||\n        original.eventType !== copied.eventType || !same(original.payload, copied.payload) ||\n        !same(original.meta, copied.meta)\n      ) return yield* Effect.fail(conflict)\n      if (isRecord(original.meta) && original.meta[\"lineageId\"] === FlowEngine.Lineage.root(sourceRunId)) {\n        return { ancestor: sourceRunId, record: original }\n      }\n      child = sourceRunId\n      entry = original\n    }\n    return yield* Effect.fail(conflict)\n  })\n\n/**\n * Accepts the occupying record only when it is `record` as a validated\n * copied-lineage ancestor emitted it; otherwise fails with `conflict`.\n *\n * The shared ancestry proof requires, at each hop, the child's fork marker above the copied prefix, the parent row the\n * marker was cut at, and the parent's own copy of the record at the same\n * `seq`, identical in content. The walk ends at the run whose lineage the\n * record carries, and that run's original must be the record being emitted\n * under that run's identity: same event type, same payload with the ancestor\n * in place of this run, same meta.\n * @category accessors\n * @since 1.0.0-rc.0\n */\nexport const accept = (options: {\n  readonly journal: Journal.Service\n  readonly runs: RunStore.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 source = (entry: JournalEvent.Entry) =>\n      entry.sourceId === record.sourceId && Number(entry.sourceSeq) === Number(sourceSeq)\n    const entry = yield* find(journal, options.runId, source)\n    if (entry === undefined || entry.eventType !== record.eventType) return yield* Effect.fail(conflict)\n    const original = yield* prove({ ...options, entry })\n    const expected = asEmittedBy(record, options.runId, original.ancestor)\n    return sameJson(original.record.payload, expected.payload) && sameJson(original.record.meta, expected.meta)\n      ? undefined\n      : yield* Effect.fail(conflict)\n  })\n"],
+  "mappings": "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",
+  "names": ["entry"]
+}