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

package/dist/cjs/internal/NodeJournal.js

@@ -0,0 +1,192 @@
+"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 NodeJournal_exports = {};
+__export(NodeJournal_exports, {
+  encodedBytes: () => encodedBytes,
+  entry: () => entry,
+  hostRoot: () => hostRoot,
+  maximumResultBytes: () => maximumResultBytes,
+  maximumSummarizedBytes: () => maximumSummarizedBytes,
+  relativePath: () => relativePath,
+  resultSummary: () => resultSummary
+});
+module.exports = __toCommonJS(NodeJournal_exports);
+var import_journal = require("@smthrs/journal");
+var JournalRecords = __toESM(require("./JournalRecords.js"), 1);
+const relativePath = import_journal.EngineEvent.relativePath;
+const asJson = (value) => JSON.parse(JSON.stringify(value));
+const hostRoot = (explicit, host = globalThis) => {
+  if (explicit !== void 0) return explicit;
+  return typeof host.process?.cwd === "function" ? host.process.cwd() : void 0;
+};
+const summary = (scope, node) => {
+  const path = node.declaredAt === void 0 ? void 0 : relativePath(scope.root, node.declaredAt.path);
+  return {
+    id: node.id,
+    kind: node.kind,
+    dependsOn: node.dependsOn,
+    tier: node.tier,
+    ...node.action === void 0 ? {} : { action: node.action },
+    ...node.effects === void 0 ? {} : { effects: asJson(node.effects) },
+    ...path === void 0 ? {} : { declaredAt: { path, line: node.declaredAt.line } }
+  };
+};
+const graph = (scope, record) => ({
+  nodes: record.nodes.map((node) => summary(scope, node)),
+  edges: record.edges,
+  // On every page, because every page carries its own sites.
+  ...scope.sourceRevision === void 0 ? {} : { sourceRevision: scope.sourceRevision }
+});
+const maximumResultBytes = 2048;
+const maximumSummarizedBytes = 65536;
+const redactor = import_journal.Redaction.make({ onTooDeep: "name" });
+const utf8Bytes = (text) => {
+  let bytes = 0;
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319 && index + 1 < text.length) {
+      bytes += 4;
+      index++;
+    } else bytes += 3;
+  }
+  return bytes;
+};
+const clampToBytes = (text, limit) => {
+  let bytes = 0;
+  let index = 0;
+  while (index < text.length) {
+    const code = text.charCodeAt(index);
+    const pair = code >= 55296 && code <= 56319 && index + 1 < text.length;
+    const size = code < 128 ? 1 : code < 2048 ? 2 : pair ? 4 : 3;
+    if (bytes + size > limit) break;
+    bytes += size;
+    index += pair ? 2 : 1;
+  }
+  return text.slice(0, index);
+};
+const resultSummary = (value) => {
+  let raw;
+  try {
+    raw = JSON.stringify(value);
+  } catch {
+    raw = void 0;
+  }
+  if (raw !== void 0) {
+    const rawBytes = utf8Bytes(raw);
+    if (rawBytes > maximumSummarizedBytes) return { preview: "", bytes: rawBytes, truncated: true };
+  }
+  let encoded;
+  try {
+    encoded = JSON.stringify(redactor(value));
+  } catch {
+    return void 0;
+  }
+  if (encoded === void 0) return void 0;
+  const bytes = utf8Bytes(encoded);
+  if (bytes > maximumSummarizedBytes) return { preview: "", bytes, truncated: true };
+  if (bytes <= maximumResultBytes) return { preview: encoded, bytes, truncated: false };
+  return { preview: clampToBytes(encoded, maximumResultBytes), bytes, truncated: true };
+};
+const entry = (scope, record) => {
+  const options = {
+    runId: scope.runId,
+    sourceId: `${scope.sourceId}/${record.sourceId}`,
+    lineageId: scope.lineageId,
+    // Without an explicit sequence the journal ALLOCATES the next one for the
+    // source, so a resumed walk would write a second row for every node it
+    // re-derived. Pinning it to zero makes the re-emission an exact producer
+    // retry, which is the whole of the exactly-once contract.
+    sourceSeq: 0,
+    // The sequence is derived from the record's own identity, so a collision
+    // is the same node observed twice rather than two nodes wearing one
+    // address. What differs between the observations is metadata ABOUT the
+    // observation — a node the first walk BUILT settles CLEAN on the walk
+    // that replayed it — and the first row, the one that says what actually
+    // happened, stands.
+    dedupe: "identity"
+  };
+  switch (record._tag) {
+    case "PlanRecorded":
+      return JournalRecords.planRecorded(options, {
+        flow: record.flow,
+        generation: record.generation,
+        // The node COUNT of the whole graph, which is what this field has
+        // always meant; the node LIST rides beside it as `graph`.
+        nodes: record.nodeCount,
+        page: record.page,
+        pages: record.pages,
+        graph: graph(scope, record)
+      });
+    case "SubgraphAppended":
+      return JournalRecords.subgraphAppended(options, {
+        flow: record.flow,
+        generation: record.generation,
+        nodeIds: record.nodes.map((node) => node.id),
+        page: record.page,
+        pages: record.pages,
+        graph: graph(scope, record)
+      });
+    case "NodeScheduled":
+      return JournalRecords.nodeScheduled(options, {
+        nodeId: record.nodeId,
+        kind: record.kind,
+        attempt: record.attempt,
+        ...record.action === void 0 ? {} : { action: record.action }
+      });
+    case "NodeSettled": {
+      const result = record.value === void 0 ? void 0 : resultSummary(record.value);
+      return JournalRecords.nodeSettled(options, {
+        nodeId: record.nodeId,
+        outcome: record.outcome,
+        attempts: record.attempts,
+        stepKeyDigests: record.stepKeyDigests,
+        ...record.action === void 0 ? {} : { action: record.action },
+        ...result === void 0 ? {} : { result }
+      });
+    }
+  }
+};
+const encodedBytes = (scope, record) => {
+  const input = entry(scope, record);
+  const sourceSeq = import_journal.JournalEvent.SourceSeq.make(0);
+  return new TextEncoder().encode(JSON.stringify({
+    runId: input.runId,
+    seq: Number.MAX_SAFE_INTEGER - 1,
+    eventId: import_journal.JournalEvent.makeEventId(input.runId, input.sourceId, sourceSeq),
+    sourceId: input.sourceId,
+    sourceSeq,
+    emittedAtMs: Number.MAX_VALUE,
+    eventType: input.eventType,
+    payload: redactor(input.payload),
+    meta: redactor(input.meta)
+  })).byteLength;
+};
+//# sourceMappingURL=NodeJournal.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/NodeJournal.ts"],
+  "sourcesContent": ["/**\n * The interpreter's node records, as journal entries.\n *\n * `@smthrs/flow` builds a record for the graph it drove and for every node it\n * scheduled and settled, and says nothing about where they go. This module is\n * the durable store's answer: one journal entry per record, addressed by the\n * record's own `sourceId`, typed by the payload schemas `@smthrs/journal`\n * publishes, and carrying the same event types the plan scheduler writes so a\n * reader folds both executors with one decoder.\n *\n * Two facts live here rather than in the interpreter. The journal's producer\n * identity is `(runId, sourceId, sourceSeq)`, so a resumed walk that\n * re-derives the same `sourceId` collapses onto the row the first walk wrote:\n * that is the exactly-once contract, and it holds because the identity is the\n * record's, never a fresh one minted per observation. And a declaration site\n * is made repo-relative here, because only the writer knows the root: a\n * journal is read on machines that did not write it, and an absolute path is\n * at best noise and at worst an operator's home directory published into a\n * run's history.\n *\n * @since 0.1.0\n */\n\nimport type { FlowRuntime } from \"@smthrs/flow\"\nimport { EngineEvent, JournalEvent, Redaction } from \"@smthrs/journal\"\nimport type * as Schema from \"effect/Schema\"\nimport * as JournalRecords from \"./JournalRecords.ts\"\n\n/**\n * Where the records of one run are addressed from.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Scope {\n  readonly runId: string\n  /** The host's journal source, which every record of this run hangs under. */\n  readonly sourceId: string\n  readonly lineageId: string\n  /**\n   * The directory a declaration path is made relative to, when one is known.\n   *\n   * `undefined` means no path is recorded at all. That is the honest answer\n   * for a host that cannot say where its sources live, and it is better than\n   * a path a reader would have to guess the meaning of.\n   */\n  readonly root?: string | undefined\n  /**\n   * The revision the sources those declaration paths point into were read\n   * at, when the host can name one.\n   *\n   * It lives here for the reason `root` does: a journal is read on machines\n   * that did not write it, and only the writer knows which tree it loaded.\n   * A path alone says where a node was declared and never which bytes were\n   * at that line, so a reader without this opens no code at all rather than\n   * whatever the working tree holds when they look (D-068).\n   */\n  readonly sourceRevision?: string | undefined\n}\n\n/**\n * A declaration path as a journal may carry it: relative to the root, or\n * nothing.\n *\n * The rule lives with the schema that refuses an absolute path\n * (`@smthrs/journal`'s `EngineEvent.DeclaredAt`), so every writer of a\n * declaration site obeys it the same way. It is named here because this is\n * the module that applies it, and because the store's own tests are written\n * against it.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const relativePath = EngineEvent.relativePath\n\n/**\n * A value the journal will serialize, typed as what it will be.\n *\n * A node's effects are JSON by construction, but an optional member spelled\n * `undefined` is not assignable to `Json` under `exactOptionalPropertyTypes`,\n * and serialization is exactly what drops it. This is the journal's own\n * encoding performed one step early, so the type says what the stored value\n * is rather than asserting it. @private\n */\nconst asJson = (value: unknown): typeof Schema.Json.Type => JSON.parse(JSON.stringify(value))\n\n/**\n * The directory declaration paths are recorded relative to.\n *\n * `process` is absent in a worker and in a browser, and a host that cannot\n * name its own working directory records no declaration path at all rather\n * than one a reader would have to guess the meaning of. `host` is the global\n * object by default and is named here so both answers are reachable without\n * taking the real one away from the runtime.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const hostRoot = (\n  explicit: string | undefined,\n  host: { readonly process?: { readonly cwd?: () => string } | undefined } = globalThis\n): string | undefined => {\n  if (explicit !== undefined) return explicit\n  return typeof host.process?.cwd === \"function\" ? host.process.cwd() : undefined\n}\n\nconst summary = (scope: Scope, node: FlowRuntime.NodeSummary) => {\n  const path = node.declaredAt === undefined ? undefined : relativePath(scope.root, node.declaredAt.path)\n  return {\n    id: node.id,\n    kind: node.kind,\n    dependsOn: node.dependsOn,\n    tier: node.tier,\n    ...(node.action === undefined ? {} : { action: node.action }),\n    ...(node.effects === undefined ? {} : { effects: asJson(node.effects) }),\n    ...(path === undefined ? {} : { declaredAt: { path, line: node.declaredAt!.line } })\n  }\n}\n\nconst graph = (scope: Scope, record: FlowRuntime.PlanRecorded | FlowRuntime.SubgraphAppended) => ({\n  nodes: record.nodes.map((node) => summary(scope, node)),\n  edges: record.edges,\n  // On every page, because every page carries its own sites.\n  ...(scope.sourceRevision === undefined ? {} : { sourceRevision: scope.sourceRevision })\n})\n\n/**\n * How many bytes of a node's settled value a journal row keeps.\n *\n * A node record is a small row beside the plan record's 12,000-byte page\n * budget, and it is written once per node of every graph: a value kept whole\n * would put an agent transcript in a permanent row and a projection would\n * clip it without saying so. Two kibibytes is enough to read what a node\n * produced and small enough that the settlement stays a summary.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const maximumResultBytes = 2_048\n\n/**\n * How large a settled value may be before it is summarized at all.\n *\n * Redacting a value rebuilds every member of it and runs the textual rules\n * over every string, on the journal write path, for every node of every\n * graph. Past this ceiling the walk is the cost rather than the row, and the\n * honest answer is the size alone: the encoding is measured, `preview` is\n * empty, and `truncated` says the text was cut to nothing. Anything below it\n * is redacted whole and then cut.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const maximumSummarizedBytes = 65_536\n\n/** The redactor a node summary is scrubbed with, built once. @private */\nconst redactor = Redaction.make({ onTooDeep: \"name\" })\n\n/** UTF-8 bytes of a string, without allocating the encoding. @private */\nconst utf8Bytes = (text: string): number => {\n  let bytes = 0\n  for (let index = 0; index < text.length; index++) {\n    const code = text.charCodeAt(index)\n    if (code < 0x80) bytes += 1\n    else if (code < 0x800) bytes += 2\n    else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {\n      bytes += 4\n      index++\n    } else bytes += 3\n  }\n  return bytes\n}\n\n/**\n * The longest prefix of `text` within `limit` UTF-8 bytes, never splitting a\n * pair.\n *\n * One cut, taken where the walk stopped, because the walk stops for two\n * reasons and only one of them can happen: the caller asks only for text it\n * has already measured as over the limit, so a second exit for text that fits\n * whole would be a line no run reaches. @private\n */\nconst clampToBytes = (text: string, limit: number): string => {\n  let bytes = 0\n  let index = 0\n  while (index < text.length) {\n    const code = text.charCodeAt(index)\n    const pair = code >= 0xd800 && code <= 0xdbff && index + 1 < text.length\n    const size = code < 0x80 ? 1 : code < 0x800 ? 2 : pair ? 4 : 3\n    if (bytes + size > limit) break\n    bytes += size\n    index += pair ? 2 : 1\n  }\n  return text.slice(0, index)\n}\n\n/**\n * What a node settled with, redacted and then bounded.\n *\n * REDACTION COMES FIRST. `Redaction.redact` is the journal's own write-path\n * scrubber, and it is the one that reads a field NAME: `{ apiKey: \"sk-...\" }`\n * is a credential because of the key, which no rule over encoded text can see\n * once the value is a string inside a larger string. Running it over the\n * decoded value also collapses cycles and names functions, so the encoding\n * that follows always succeeds. Cutting the text first would be worse than\n * useless: a credential split across the boundary is a credential the textual\n * rules no longer recognise, and half of it would be kept.\n *\n * A value that will not encode even after redaction \u2014 a bigint, a value whose\n * own `toJSON` throws \u2014 gets no summary at all rather than a fabricated one.\n *\n * `bytes` is the size of the encoding `preview` was cut from, which for a\n * value past {@link maximumSummarizedBytes} is the value's own encoding: that\n * branch keeps nothing, so there is no second number to disagree with.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const resultSummary = (value: unknown): {\n  readonly preview: string\n  readonly bytes: number\n  readonly truncated: boolean\n} | undefined => {\n  // The size first, from the value's own encoding, because it is the cheap\n  // half: a value this row will not keep is named by its size and never\n  // walked. A value that will not encode at all \u2014 a cycle, a bigint, a\n  // throwing `toJSON` \u2014 says nothing here, and the redactor below is asked,\n  // because it collapses cycles and names what it cannot rewrite.\n  let raw: string | undefined\n  try {\n    raw = JSON.stringify(value)\n  } catch {\n    raw = undefined\n  }\n  if (raw !== undefined) {\n    const rawBytes = utf8Bytes(raw)\n    if (rawBytes > maximumSummarizedBytes) return { preview: \"\", bytes: rawBytes, truncated: true }\n  }\n  let encoded: string | undefined\n  try {\n    encoded = JSON.stringify(redactor(value))\n  } catch {\n    return undefined\n  }\n  if (encoded === undefined) return undefined\n  const bytes = utf8Bytes(encoded)\n  if (bytes > maximumSummarizedBytes) return { preview: \"\", bytes, truncated: true }\n  if (bytes <= maximumResultBytes) return { preview: encoded, bytes, truncated: false }\n  return { preview: clampToBytes(encoded, maximumResultBytes), bytes, truncated: true }\n}\n\n/**\n * The journal entry one node record is written as.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const entry = (scope: Scope, record: FlowRuntime.NodeRecord): JournalEvent.Input => {\n  const options = {\n    runId: scope.runId,\n    sourceId: `${scope.sourceId}/${record.sourceId}`,\n    lineageId: scope.lineageId,\n    // Without an explicit sequence the journal ALLOCATES the next one for the\n    // source, so a resumed walk would write a second row for every node it\n    // re-derived. Pinning it to zero makes the re-emission an exact producer\n    // retry, which is the whole of the exactly-once contract.\n    sourceSeq: 0,\n    // The sequence is derived from the record's own identity, so a collision\n    // is the same node observed twice rather than two nodes wearing one\n    // address. What differs between the observations is metadata ABOUT the\n    // observation \u2014 a node the first walk BUILT settles CLEAN on the walk\n    // that replayed it \u2014 and the first row, the one that says what actually\n    // happened, stands.\n    dedupe: \"identity\" as const\n  }\n  switch (record._tag) {\n    case \"PlanRecorded\":\n      return JournalRecords.planRecorded(options, {\n        flow: record.flow,\n        generation: record.generation,\n        // The node COUNT of the whole graph, which is what this field has\n        // always meant; the node LIST rides beside it as `graph`.\n        nodes: record.nodeCount,\n        page: record.page,\n        pages: record.pages,\n        graph: graph(scope, record)\n      })\n    case \"SubgraphAppended\":\n      return JournalRecords.subgraphAppended(options, {\n        flow: record.flow,\n        generation: record.generation,\n        nodeIds: record.nodes.map((node) => node.id),\n        page: record.page,\n        pages: record.pages,\n        graph: graph(scope, record)\n      })\n    case \"NodeScheduled\":\n      return JournalRecords.nodeScheduled(options, {\n        nodeId: record.nodeId,\n        kind: record.kind,\n        attempt: record.attempt,\n        ...(record.action === undefined ? {} : { action: record.action })\n      })\n    case \"NodeSettled\": {\n      const result = record.value === undefined ? undefined : resultSummary(record.value)\n      return JournalRecords.nodeSettled(options, {\n        nodeId: record.nodeId,\n        outcome: record.outcome,\n        attempts: record.attempts,\n        stepKeyDigests: record.stepKeyDigests,\n        ...(record.action === undefined ? {} : { action: record.action }),\n        ...(result === undefined ? {} : { result })\n      })\n    }\n  }\n}\n\n/**\n * UTF-8 upper bound for the durable entry, including allocated envelope fields.\n *\n * Sequence/time reserve their largest JSON encodings so page boundaries never\n * depend on the current journal position or clock, including after a resume.\n * @since 1.0.0\n * @category accessors\n */\nexport const encodedBytes = (scope: Scope, record: FlowRuntime.NodeRecord): number => {\n  const input = entry(scope, record)\n  const sourceSeq = JournalEvent.SourceSeq.make(0)\n  return new TextEncoder().encode(JSON.stringify({\n    runId: input.runId,\n    seq: Number.MAX_SAFE_INTEGER - 1,\n    eventId: JournalEvent.makeEventId(input.runId, input.sourceId, sourceSeq),\n    sourceId: input.sourceId,\n    sourceSeq,\n    emittedAtMs: Number.MAX_VALUE,\n    eventType: input.eventType,\n    payload: redactor(input.payload),\n    meta: redactor(input.meta)\n  })).byteLength\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBA,qBAAqD;AAErD,qBAAgC;AA+CzB,MAAM,eAAe,2BAAY;AAWxC,MAAM,SAAS,CAAC,UAA4C,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;AAcrF,MAAM,WAAW,CACtB,UACA,OAA2E,eACpD;AACvB,MAAI,aAAa,OAAW,QAAO;AACnC,SAAO,OAAO,KAAK,SAAS,QAAQ,aAAa,KAAK,QAAQ,IAAI,IAAI;AACxE;AAEA,MAAM,UAAU,CAAC,OAAc,SAAkC;AAC/D,QAAM,OAAO,KAAK,eAAe,SAAY,SAAY,aAAa,MAAM,MAAM,KAAK,WAAW,IAAI;AACtG,SAAO;AAAA,IACL,IAAI,KAAK;AAAA,IACT,MAAM,KAAK;AAAA,IACX,WAAW,KAAK;AAAA,IAChB,MAAM,KAAK;AAAA,IACX,GAAI,KAAK,WAAW,SAAY,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO;AAAA,IAC3D,GAAI,KAAK,YAAY,SAAY,CAAC,IAAI,EAAE,SAAS,OAAO,KAAK,OAAO,EAAE;AAAA,IACtE,GAAI,SAAS,SAAY,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,MAAM,KAAK,WAAY,KAAK,EAAE;AAAA,EACpF;AACF;AAEA,MAAM,QAAQ,CAAC,OAAc,YAAqE;AAAA,EAChG,OAAO,OAAO,MAAM,IAAI,CAAC,SAAS,QAAQ,OAAO,IAAI,CAAC;AAAA,EACtD,OAAO,OAAO;AAAA;AAAA,EAEd,GAAI,MAAM,mBAAmB,SAAY,CAAC,IAAI,EAAE,gBAAgB,MAAM,eAAe;AACvF;AAcO,MAAM,qBAAqB;AAe3B,MAAM,yBAAyB;AAGtC,MAAM,WAAW,yBAAU,KAAK,EAAE,WAAW,OAAO,CAAC;AAGrD,MAAM,YAAY,CAAC,SAAyB;AAC1C,MAAI,QAAQ;AACZ,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS;AAChD,UAAM,OAAO,KAAK,WAAW,KAAK;AAClC,QAAI,OAAO,IAAM,UAAS;AAAA,aACjB,OAAO,KAAO,UAAS;AAAA,aACvB,QAAQ,SAAU,QAAQ,SAAU,QAAQ,IAAI,KAAK,QAAQ;AACpE,eAAS;AACT;AAAA,IACF,MAAO,UAAS;AAAA,EAClB;AACA,SAAO;AACT;AAWA,MAAM,eAAe,CAAC,MAAc,UAA0B;AAC5D,MAAI,QAAQ;AACZ,MAAI,QAAQ;AACZ,SAAO,QAAQ,KAAK,QAAQ;AAC1B,UAAM,OAAO,KAAK,WAAW,KAAK;AAClC,UAAM,OAAO,QAAQ,SAAU,QAAQ,SAAU,QAAQ,IAAI,KAAK;AAClE,UAAM,OAAO,OAAO,MAAO,IAAI,OAAO,OAAQ,IAAI,OAAO,IAAI;AAC7D,QAAI,QAAQ,OAAO,MAAO;AAC1B,aAAS;AACT,aAAS,OAAO,IAAI;AAAA,EACtB;AACA,SAAO,KAAK,MAAM,GAAG,KAAK;AAC5B;AAwBO,MAAM,gBAAgB,CAAC,UAIb;AAMf,MAAI;AACJ,MAAI;AACF,UAAM,KAAK,UAAU,KAAK;AAAA,EAC5B,QAAQ;AACN,UAAM;AAAA,EACR;AACA,MAAI,QAAQ,QAAW;AACrB,UAAM,WAAW,UAAU,GAAG;AAC9B,QAAI,WAAW,uBAAwB,QAAO,EAAE,SAAS,IAAI,OAAO,UAAU,WAAW,KAAK;AAAA,EAChG;AACA,MAAI;AACJ,MAAI;AACF,cAAU,KAAK,UAAU,SAAS,KAAK,CAAC;AAAA,EAC1C,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI,YAAY,OAAW,QAAO;AAClC,QAAM,QAAQ,UAAU,OAAO;AAC/B,MAAI,QAAQ,uBAAwB,QAAO,EAAE,SAAS,IAAI,OAAO,WAAW,KAAK;AACjF,MAAI,SAAS,mBAAoB,QAAO,EAAE,SAAS,SAAS,OAAO,WAAW,MAAM;AACpF,SAAO,EAAE,SAAS,aAAa,SAAS,kBAAkB,GAAG,OAAO,WAAW,KAAK;AACtF;AAQO,MAAM,QAAQ,CAAC,OAAc,WAAuD;AACzF,QAAM,UAAU;AAAA,IACd,OAAO,MAAM;AAAA,IACb,UAAU,GAAG,MAAM,QAAQ,IAAI,OAAO,QAAQ;AAAA,IAC9C,WAAW,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,IAKjB,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOX,QAAQ;AAAA,EACV;AACA,UAAQ,OAAO,MAAM;AAAA,IACnB,KAAK;AACH,aAAO,eAAe,aAAa,SAAS;AAAA,QAC1C,MAAM,OAAO;AAAA,QACb,YAAY,OAAO;AAAA;AAAA;AAAA,QAGnB,OAAO,OAAO;AAAA,QACd,MAAM,OAAO;AAAA,QACb,OAAO,OAAO;AAAA,QACd,OAAO,MAAM,OAAO,MAAM;AAAA,MAC5B,CAAC;AAAA,IACH,KAAK;AACH,aAAO,eAAe,iBAAiB,SAAS;AAAA,QAC9C,MAAM,OAAO;AAAA,QACb,YAAY,OAAO;AAAA,QACnB,SAAS,OAAO,MAAM,IAAI,CAAC,SAAS,KAAK,EAAE;AAAA,QAC3C,MAAM,OAAO;AAAA,QACb,OAAO,OAAO;AAAA,QACd,OAAO,MAAM,OAAO,MAAM;AAAA,MAC5B,CAAC;AAAA,IACH,KAAK;AACH,aAAO,eAAe,cAAc,SAAS;AAAA,QAC3C,QAAQ,OAAO;AAAA,QACf,MAAM,OAAO;AAAA,QACb,SAAS,OAAO;AAAA,QAChB,GAAI,OAAO,WAAW,SAAY,CAAC,IAAI,EAAE,QAAQ,OAAO,OAAO;AAAA,MACjE,CAAC;AAAA,IACH,KAAK,eAAe;AAClB,YAAM,SAAS,OAAO,UAAU,SAAY,SAAY,cAAc,OAAO,KAAK;AAClF,aAAO,eAAe,YAAY,SAAS;AAAA,QACzC,QAAQ,OAAO;AAAA,QACf,SAAS,OAAO;AAAA,QAChB,UAAU,OAAO;AAAA,QACjB,gBAAgB,OAAO;AAAA,QACvB,GAAI,OAAO,WAAW,SAAY,CAAC,IAAI,EAAE,QAAQ,OAAO,OAAO;AAAA,QAC/D,GAAI,WAAW,SAAY,CAAC,IAAI,EAAE,OAAO;AAAA,MAC3C,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAUO,MAAM,eAAe,CAAC,OAAc,WAA2C;AACpF,QAAM,QAAQ,MAAM,OAAO,MAAM;AACjC,QAAM,YAAY,4BAAa,UAAU,KAAK,CAAC;AAC/C,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK,UAAU;AAAA,IAC7C,OAAO,MAAM;AAAA,IACb,KAAK,OAAO,mBAAmB;AAAA,IAC/B,SAAS,4BAAa,YAAY,MAAM,OAAO,MAAM,UAAU,SAAS;AAAA,IACxE,UAAU,MAAM;AAAA,IAChB;AAAA,IACA,aAAa,OAAO;AAAA,IACpB,WAAW,MAAM;AAAA,IACjB,SAAS,SAAS,MAAM,OAAO;AAAA,IAC/B,MAAM,SAAS,MAAM,IAAI;AAAA,EAC3B,CAAC,CAAC,EAAE;AACN;",
+  "names": []
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Host-locale-independent UTF-16 code-unit ordering for durable material.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Compares two strings by JavaScript's locale-independent UTF-16 relational
+ * order.
+ *
+ * @category ordering
+ * @since 1.0.0
+ */
+export declare const compareText: (left: string, right: string) => number;
+//# sourceMappingURL=Ordering.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Ordering.d.ts","sourceRoot":"","sources":["../../../src/internal/Ordering.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,KAAG,MAAkD,CAAA"}

package/dist/cjs/internal/Ordering.js

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Ordering_exports = {};
+__export(Ordering_exports, {
+  compareText: () => compareText
+});
+module.exports = __toCommonJS(Ordering_exports);
+const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+//# sourceMappingURL=Ordering.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Ordering.ts"],
+  "sourcesContent": ["/**\n * Host-locale-independent UTF-16 code-unit ordering for durable material.\n *\n * @since 1.0.0\n */\n\n/**\n * Compares two strings by JavaScript's locale-independent UTF-16 relational\n * order.\n *\n * @category ordering\n * @since 1.0.0\n */\nexport const compareText = (left: string, right: string): number => left < right ? -1 : left > right ? 1 : 0\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,MAAM,cAAc,CAAC,MAAc,UAA0B,OAAO,QAAQ,KAAK,OAAO,QAAQ,IAAI;",
+  "names": []
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Cross-check stored or newly measured observations against a verified plan.
+ * @since 1.0.0
+ */
+import { FileSet, type Plan } from "@smthrs/plan";
+import { Effect } from "effect";
+import * as PlanInputStore from "../PlanInputStore.ts";
+/**
+ * Validates without publishing or mutating either the old pins or observations.
+ * @since 1.0.0
+ * @category validation
+ */
+export declare const validate: (snapshot: PlanInputStore.Snapshot, nodes: ReadonlyArray<Plan.PlanNode>, pinned: ReadonlyMap<string, string>, writerScopesBefore: (node: Plan.PlanNode) => ReadonlyArray<FileSet.Entry>) => Effect.Effect<Map<string, string>, PlanInputStore.PlanInputError>;
+//# sourceMappingURL=PlanInputs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PlanInputs.d.ts","sourceRoot":"","sources":["../../../src/internal/PlanInputs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA;AAEtD;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GACnB,UAAU,cAAc,CAAC,QAAQ,EACjC,OAAO,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,EACnC,QAAQ,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACnC,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,KAAK,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,KACxE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,CAAC,cAAc,CA0C/D,CAAA"}

package/dist/cjs/internal/PlanInputs.js

@@ -0,0 +1,78 @@
+"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 PlanInputs_exports = {};
+__export(PlanInputs_exports, {
+  validate: () => validate
+});
+module.exports = __toCommonJS(PlanInputs_exports);
+var import_plan = require("@smthrs/plan");
+var import_effect = require("effect");
+var PlanInputStore = __toESM(require("../PlanInputStore.js"), 1);
+const validate = (snapshot, nodes, pinned, writerScopesBefore) => import_effect.Effect.gen(function* () {
+  const corrupt = (message) => import_effect.Effect.fail(new PlanInputStore.PlanInputError({ code: "corrupt_state", message }));
+  if (snapshot.nodes.length !== nodes.length) return yield* corrupt("source observation node count changed");
+  const nextPins = new Map(pinned);
+  const newPins = /* @__PURE__ */ new Set();
+  for (const pin of snapshot.pins) {
+    if (nextPins.has(pin.path)) return yield* corrupt("a later generation replaced an existing source pin");
+    nextPins.set(pin.path, pin.digest);
+    newPins.add(pin.path);
+  }
+  for (let index = 0; index < nodes.length; index++) {
+    const node = nodes[index];
+    const recorded = snapshot.nodes[index];
+    const reads = import_plan.FileSet.expandReads(node.effects.reads);
+    const writerScopes = reads.length === 0 ? [] : writerScopesBefore(node);
+    if (recorded.id !== node.id || recorded.key !== node.key || recorded.reads.length !== reads.length) {
+      return yield* corrupt("source observation does not match its plan node");
+    }
+    for (let readIndex = 0; readIndex < reads.length; readIndex++) {
+      const expected = import_effect.Schema.decodeUnknownSync(import_plan.FileSet.ReadEntry)(reads[readIndex]);
+      const read = recorded.reads[readIndex];
+      if (JSON.stringify(read.entry) !== JSON.stringify(expected)) {
+        return yield* corrupt("source observation declaration changed");
+      }
+      if (typeof expected === "string") {
+        const source = !writerScopes.some((scope) => import_plan.FileSet.overlaps(scope, expected));
+        if (read.sourcePaths.length !== (source ? 1 : 0)) {
+          return yield* corrupt("source observation selects the wrong file version");
+        }
+      }
+      for (const path of read.sourcePaths) {
+        if (!nextPins.has(path) || writerScopes.some((scope) => import_plan.FileSet.overlaps(scope, path))) {
+          return yield* corrupt("source observation has a missing pin or preceding writer");
+        }
+        newPins.delete(path);
+      }
+    }
+  }
+  if (newPins.size > 0) return yield* corrupt("source observation contains unreferenced pins");
+  return nextPins;
+});
+//# sourceMappingURL=PlanInputs.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/PlanInputs.ts"],
+  "sourcesContent": ["/**\n * Cross-check stored or newly measured observations against a verified plan.\n * @since 1.0.0\n */\n\nimport { FileSet, type Plan } from \"@smthrs/plan\"\nimport { Effect, Schema } from \"effect\"\nimport * as PlanInputStore from \"../PlanInputStore.ts\"\n\n/**\n * Validates without publishing or mutating either the old pins or observations.\n * @since 1.0.0\n * @category validation\n */\nexport const validate = (\n  snapshot: PlanInputStore.Snapshot,\n  nodes: ReadonlyArray<Plan.PlanNode>,\n  pinned: ReadonlyMap<string, string>,\n  writerScopesBefore: (node: Plan.PlanNode) => ReadonlyArray<FileSet.Entry>\n): Effect.Effect<Map<string, string>, PlanInputStore.PlanInputError> =>\n  Effect.gen(function*() {\n    const corrupt = (message: string) =>\n      Effect.fail(new PlanInputStore.PlanInputError({ code: \"corrupt_state\", message }))\n    if (snapshot.nodes.length !== nodes.length) return yield* corrupt(\"source observation node count changed\")\n    const nextPins = new Map(pinned)\n    const newPins = new Set<string>()\n    for (const pin of snapshot.pins) {\n      if (nextPins.has(pin.path)) return yield* corrupt(\"a later generation replaced an existing source pin\")\n      nextPins.set(pin.path, pin.digest)\n      newPins.add(pin.path)\n    }\n    for (let index = 0; index < nodes.length; index++) {\n      const node = nodes[index]!\n      const recorded = snapshot.nodes[index]!\n      const reads = FileSet.expandReads(node.effects.reads)\n      const writerScopes = reads.length === 0 ? [] : writerScopesBefore(node)\n      if (recorded.id !== node.id || recorded.key !== node.key || recorded.reads.length !== reads.length) {\n        return yield* corrupt(\"source observation does not match its plan node\")\n      }\n      for (let readIndex = 0; readIndex < reads.length; readIndex++) {\n        const expected = Schema.decodeUnknownSync(FileSet.ReadEntry)(reads[readIndex]!)\n        const read = recorded.reads[readIndex]!\n        if (JSON.stringify(read.entry) !== JSON.stringify(expected)) {\n          return yield* corrupt(\"source observation declaration changed\")\n        }\n        if (typeof expected === \"string\") {\n          const source = !writerScopes.some((scope) => FileSet.overlaps(scope, expected))\n          if (read.sourcePaths.length !== (source ? 1 : 0)) {\n            return yield* corrupt(\"source observation selects the wrong file version\")\n          }\n        }\n        for (const path of read.sourcePaths) {\n          if (!nextPins.has(path) || writerScopes.some((scope) => FileSet.overlaps(scope, path))) {\n            return yield* corrupt(\"source observation has a missing pin or preceding writer\")\n          }\n          newPins.delete(path)\n        }\n      }\n    }\n    if (newPins.size > 0) return yield* corrupt(\"source observation contains unreferenced pins\")\n    return nextPins\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,kBAAmC;AACnC,oBAA+B;AAC/B,qBAAgC;AAOzB,MAAM,WAAW,CACtB,UACA,OACA,QACA,uBAEA,qBAAO,IAAI,aAAY;AACrB,QAAM,UAAU,CAAC,YACf,qBAAO,KAAK,IAAI,eAAe,eAAe,EAAE,MAAM,iBAAiB,QAAQ,CAAC,CAAC;AACnF,MAAI,SAAS,MAAM,WAAW,MAAM,OAAQ,QAAO,OAAO,QAAQ,uCAAuC;AACzG,QAAM,WAAW,IAAI,IAAI,MAAM;AAC/B,QAAM,UAAU,oBAAI,IAAY;AAChC,aAAW,OAAO,SAAS,MAAM;AAC/B,QAAI,SAAS,IAAI,IAAI,IAAI,EAAG,QAAO,OAAO,QAAQ,oDAAoD;AACtG,aAAS,IAAI,IAAI,MAAM,IAAI,MAAM;AACjC,YAAQ,IAAI,IAAI,IAAI;AAAA,EACtB;AACA,WAAS,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;AACjD,UAAM,OAAO,MAAM,KAAK;AACxB,UAAM,WAAW,SAAS,MAAM,KAAK;AACrC,UAAM,QAAQ,oBAAQ,YAAY,KAAK,QAAQ,KAAK;AACpD,UAAM,eAAe,MAAM,WAAW,IAAI,CAAC,IAAI,mBAAmB,IAAI;AACtE,QAAI,SAAS,OAAO,KAAK,MAAM,SAAS,QAAQ,KAAK,OAAO,SAAS,MAAM,WAAW,MAAM,QAAQ;AAClG,aAAO,OAAO,QAAQ,iDAAiD;AAAA,IACzE;AACA,aAAS,YAAY,GAAG,YAAY,MAAM,QAAQ,aAAa;AAC7D,YAAM,WAAW,qBAAO,kBAAkB,oBAAQ,SAAS,EAAE,MAAM,SAAS,CAAE;AAC9E,YAAM,OAAO,SAAS,MAAM,SAAS;AACrC,UAAI,KAAK,UAAU,KAAK,KAAK,MAAM,KAAK,UAAU,QAAQ,GAAG;AAC3D,eAAO,OAAO,QAAQ,wCAAwC;AAAA,MAChE;AACA,UAAI,OAAO,aAAa,UAAU;AAChC,cAAM,SAAS,CAAC,aAAa,KAAK,CAAC,UAAU,oBAAQ,SAAS,OAAO,QAAQ,CAAC;AAC9E,YAAI,KAAK,YAAY,YAAY,SAAS,IAAI,IAAI;AAChD,iBAAO,OAAO,QAAQ,mDAAmD;AAAA,QAC3E;AAAA,MACF;AACA,iBAAW,QAAQ,KAAK,aAAa;AACnC,YAAI,CAAC,SAAS,IAAI,IAAI,KAAK,aAAa,KAAK,CAAC,UAAU,oBAAQ,SAAS,OAAO,IAAI,CAAC,GAAG;AACtF,iBAAO,OAAO,QAAQ,0DAA0D;AAAA,QAClF;AACA,gBAAQ,OAAO,IAAI;AAAA,MACrB;AAAA,IACF;AAAA,EACF;AACA,MAAI,QAAQ,OAAO,EAAG,QAAO,OAAO,QAAQ,+CAA+C;AAC3F,SAAO;AACT,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,178 @@
+/** Durable merge recovery and generated identity, independent of dispatch.
+ * @since 1.0.0
+ */
+import { Plan } from "@smthrs/plan";
+import { Effect } from "effect";
+import * as PlanMergeStore from "../PlanMergeStore.ts";
+/** Chooses a free display ID; ownership comes from the durable decision, not this spelling.
+ * @since 1.0.0
+ * @category identity
+ */
+export declare const allocateId: (plan: Plan.Plan, nodeId: string) => string;
+/** The single declaration used both when appending and when recovering an extension.
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const draft: (node: Plan.PlanNode, mergeId: string, winners: ReadonlyArray<string>) => Plan.NodeDraft;
+/** Checks that an intent names a permissible stopped node and its actual conflict peers.
+ * @since 1.0.0
+ * @category validation
+ */
+export declare const validateIntent: (plan: Plan.Plan, intent: PlanMergeStore.Intent) => Effect.Effect<{
+    readonly id: string;
+    readonly kind: "step" | "agent" | "merge";
+    readonly key: string & import("effect/Brand").Brand<"@smthrs/keys/Key">;
+    readonly material: {
+        readonly kind: "sealed" | "compensable" | "irreversible";
+        readonly body: unknown;
+        readonly version: "flows/key-material/v2";
+        readonly layers: readonly string[];
+        readonly capabilities: readonly string[];
+        readonly inputs: readonly ({
+            readonly _tag: "Literal";
+            readonly value: unknown;
+        } | {
+            readonly _tag: "Ref";
+            readonly from: string;
+            readonly path: readonly string[];
+        } | {
+            readonly _tag: "Pending";
+            readonly from: string;
+        })[];
+        readonly effects?: unknown;
+        readonly nondeterministic?: true | undefined;
+        readonly placement?: unknown;
+    };
+    readonly effects: {
+        readonly boundaryMode: "expected" | "hard";
+        readonly reads: readonly (string | {
+            readonly _tag: "Glob";
+            readonly include: readonly [string, ...string[]];
+            readonly exclude?: readonly string[] | undefined;
+        } | {
+            readonly _tag: "Filegroup";
+            readonly name: string;
+            readonly entries: readonly (string | {
+                readonly _tag: "Glob";
+                readonly include: readonly [string, ...string[]];
+                readonly exclude?: readonly string[] | undefined;
+            })[];
+        })[];
+        readonly writes: readonly (string | {
+            readonly _tag: "Glob";
+            readonly include: readonly [string, ...string[]];
+            readonly exclude?: readonly string[] | undefined;
+        } | {
+            readonly _tag: "TreeArtifact";
+            readonly path: string;
+        } | {
+            readonly _tag: "Filegroup";
+            readonly name: string;
+            readonly entries: readonly (string | {
+                readonly _tag: "Glob";
+                readonly include: readonly [string, ...string[]];
+                readonly exclude?: readonly string[] | undefined;
+            } | {
+                readonly _tag: "TreeArtifact";
+                readonly path: string;
+            })[];
+        })[];
+        readonly removes?: readonly string[] | undefined;
+    };
+    readonly dependsOn: readonly string[];
+    readonly conflicts: readonly {
+        readonly with: string;
+        readonly paths: readonly string[];
+        readonly strategy: "serialize" | "lane" | "fail";
+        readonly runtime: "delay-rebase" | "stop-merge";
+    }[];
+    readonly strategy: "serialize" | "lane" | "fail";
+    readonly runtime: "delay-rebase" | "stop-merge";
+    readonly priority: number;
+    readonly generation: number;
+}, PlanMergeStore.PlanMergeError, never>;
+/** Recovers only recorded merge extensions, never unrelated/unapproved appended work.
+ * @since 1.0.0
+ * @category recovery
+ */
+export declare const recover: (candidate: Plan.Plan, decisions: ReadonlyArray<PlanMergeStore.Decision>) => Effect.Effect<{
+    readonly planId: string;
+    readonly flow: string;
+    readonly generation: number;
+    readonly baseDigest: string & import("effect/Brand").Brand<"@smthrs/keys/Key">;
+    readonly digest: string & import("effect/Brand").Brand<"@smthrs/keys/Key">;
+    readonly nodes: readonly {
+        readonly id: string;
+        readonly kind: "step" | "agent" | "merge";
+        readonly key: string & import("effect/Brand").Brand<"@smthrs/keys/Key">;
+        readonly material: {
+            readonly kind: "sealed" | "compensable" | "irreversible";
+            readonly body: unknown;
+            readonly version: "flows/key-material/v2";
+            readonly layers: readonly string[];
+            readonly capabilities: readonly string[];
+            readonly inputs: readonly ({
+                readonly _tag: "Literal";
+                readonly value: unknown;
+            } | {
+                readonly _tag: "Ref";
+                readonly from: string;
+                readonly path: readonly string[];
+            } | {
+                readonly _tag: "Pending";
+                readonly from: string;
+            })[];
+            readonly effects?: unknown;
+            readonly nondeterministic?: true | undefined;
+            readonly placement?: unknown;
+        };
+        readonly effects: {
+            readonly boundaryMode: "expected" | "hard";
+            readonly reads: readonly (string | {
+                readonly _tag: "Glob";
+                readonly include: readonly [string, ...string[]];
+                readonly exclude?: readonly string[] | undefined;
+            } | {
+                readonly _tag: "Filegroup";
+                readonly name: string;
+                readonly entries: readonly (string | {
+                    readonly _tag: "Glob";
+                    readonly include: readonly [string, ...string[]];
+                    readonly exclude?: readonly string[] | undefined;
+                })[];
+            })[];
+            readonly writes: readonly (string | {
+                readonly _tag: "Glob";
+                readonly include: readonly [string, ...string[]];
+                readonly exclude?: readonly string[] | undefined;
+            } | {
+                readonly _tag: "TreeArtifact";
+                readonly path: string;
+            } | {
+                readonly _tag: "Filegroup";
+                readonly name: string;
+                readonly entries: readonly (string | {
+                    readonly _tag: "Glob";
+                    readonly include: readonly [string, ...string[]];
+                    readonly exclude?: readonly string[] | undefined;
+                } | {
+                    readonly _tag: "TreeArtifact";
+                    readonly path: string;
+                })[];
+            })[];
+            readonly removes?: readonly string[] | undefined;
+        };
+        readonly dependsOn: readonly string[];
+        readonly conflicts: readonly {
+            readonly with: string;
+            readonly paths: readonly string[];
+            readonly strategy: "serialize" | "lane" | "fail";
+            readonly runtime: "delay-rebase" | "stop-merge";
+        }[];
+        readonly strategy: "serialize" | "lane" | "fail";
+        readonly runtime: "delay-rebase" | "stop-merge";
+        readonly priority: number;
+        readonly generation: number;
+    }[];
+}, PlanMergeStore.PlanMergeError, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=PlanMerges.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PlanMerges.d.ts","sourceRoot":"","sources":["../../../src/internal/PlanMerges.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAe,IAAI,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA;AAQtD;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,CAAC,IAAI,EAAE,QAAQ,MAAM,KAAG,MAM5D,CAAA;AACD;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,KAAG,IAAI,CAAC,SAYhG,CAAA;AACF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,IAAI,CAAC,IAAI,EAAE,QAAQ,cAAc,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAWzE,CAAA;AACJ;;;GAGG;AACH,eAAO,MAAM,OAAO,GAAI,WAAW,IAAI,CAAC,IAAI,EAAE,WAAW,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEA4D3F,CAAA"}