@smthrs/plan 0.0.0-stage → 1.0.0-rc.13

package/dist/cjs/internal/ConflictAnnotation.js

@@ -0,0 +1,247 @@
+"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 ConflictAnnotation_exports = {};
+__export(ConflictAnnotation_exports, {
+  annotate: () => annotate
+});
+module.exports = __toCommonJS(ConflictAnnotation_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var FileSet = __toESM(require("../FileSet.js"), 1);
+var KeyMaterial = __toESM(require("../KeyMaterial.js"), 1);
+var EffectCandidates = __toESM(require("./EffectCandidates.js"), 1);
+const refuse = (code, message) => Effect.fail({ code, message });
+const pairStrategy = (left, right) => left === "fail" || right === "fail" ? "fail" : left === "lane" || right === "lane" ? "lane" : "serialize";
+const pairRuntime = (left, right) => left === "stop-merge" || right === "stop-merge" ? "stop-merge" : "delay-rebase";
+const producedPaths = (effects) => [
+  ...FileSet.expand(effects.writes),
+  ...effects.removes ?? []
+];
+const describe = (entry) => typeof entry === "string" ? entry : entry._tag === "TreeArtifact" ? entry.path : entry.include.join(",");
+const overlap = (left, right) => left.flatMap(
+  (leftEntry) => right.some((rightEntry) => FileSet.overlaps(leftEntry, rightEntry)) ? [describe(leftEntry)] : []
+);
+const readOverlap = (reads, produced) => reads.flatMap((entry) => produced.some((output) => FileSet.overlaps(entry, output)) ? [describe(entry)] : []);
+const annotate = (nodes, frozen, replayGenerations) => Effect.gen(function* () {
+  const expanded = new Map(nodes.map((node) => [node.id, {
+    produced: producedPaths(node.effects),
+    reads: FileSet.expandReads(node.effects.reads)
+  }]));
+  const candidates = EffectCandidates.make(nodes.map((node) => expanded.get(node.id).produced));
+  const conflicts = /* @__PURE__ */ new Map();
+  const ordering = /* @__PURE__ */ new Map();
+  const edges = new Map(nodes.map((node) => [node.id, new Set(node.dependsOn)]));
+  const declaredEdges = new Map(nodes.map((node) => [node.id, KeyMaterial.dependencies(node.material)]));
+  const ordinals = new Map(nodes.map((node, index) => [node.id, index]));
+  const dependents = new Map(nodes.map((node) => [node.id, /* @__PURE__ */ new Set()]));
+  for (const node of nodes) {
+    for (const dependency of node.dependsOn) dependents.get(dependency).add(node.id);
+  }
+  const words = Math.ceil(nodes.length / 32);
+  const ancestors = /* @__PURE__ */ new Map();
+  let work = 0;
+  let pairs = 0;
+  let nextYield = 2048;
+  const checkpoint = Effect.gen(function* () {
+    if (work > 1e7 || pairs > 25e4) {
+      return yield* refuse(
+        "graph_too_large",
+        "Plan effect analysis exceeds its work budget (10000000 work units or 250000 candidate pairs)"
+      );
+    }
+    nextYield = Math.min(work + 2048, 10000001);
+    yield* Effect.yieldNow;
+  });
+  const closure = (id) => Effect.gen(function* () {
+    const cached = ancestors.get(id);
+    if (cached !== void 0) return cached;
+    const frame = (id2) => {
+      const bits = new Uint32Array(words);
+      const ordinal = ordinals.get(id2);
+      bits[ordinal >>> 5] |= 1 << (ordinal & 31);
+      return { id: id2, bits, dependencies: Array.from(edges.get(id2)), next: 0 };
+    };
+    const stack = [frame(id)];
+    while (stack.length > 0) {
+      const current = stack[stack.length - 1];
+      const dependency = current.dependencies[current.next];
+      if (dependency === void 0) {
+        ancestors.set(current.id, current.bits);
+        stack.pop();
+        continue;
+      }
+      const bits = ancestors.get(dependency);
+      if (bits === void 0) {
+        stack.push(frame(dependency));
+        continue;
+      }
+      for (let word = 0; word < words; word++) {
+        current.bits[word] |= bits[word];
+        if (++work >= nextYield) yield* checkpoint;
+      }
+      current.next++;
+    }
+    return ancestors.get(id);
+  });
+  const reaches = (from, to) => Effect.gen(function* () {
+    const bits = yield* closure(from);
+    const ordinal = ordinals.get(to);
+    return (bits[ordinal >>> 5] & 1 << (ordinal & 31)) !== 0;
+  });
+  const addEdge = (from, to) => Effect.gen(function* () {
+    const source = yield* closure(from);
+    const target = yield* closure(to);
+    for (let word = 0; word < words; word++) {
+      source[word] |= target[word];
+      if (++work >= nextYield) yield* checkpoint;
+    }
+    const stack = [from];
+    while (stack.length > 0) {
+      for (const dependent of dependents.get(stack.pop())) {
+        if (++work >= nextYield) yield* checkpoint;
+        if (!ancestors.delete(dependent)) continue;
+        stack.push(dependent);
+      }
+    }
+    edges.get(from).add(to);
+    dependents.get(to).add(from);
+  });
+  const route = (from, to, graph = edges) => Effect.gen(function* () {
+    const arrivedFrom = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set([from]);
+    const stack = [from];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current === to) {
+        const chain = [current];
+        for (let step = arrivedFrom.get(current); step !== void 0; step = arrivedFrom.get(step)) {
+          chain.push(step);
+        }
+        return chain.reverse();
+      }
+      for (const next of graph.get(current)) {
+        if (++work >= nextYield) yield* checkpoint;
+        if (seen.has(next)) continue;
+        seen.add(next);
+        arrivedFrom.set(next, current);
+        stack.push(next);
+      }
+    }
+    return void 0;
+  });
+  const ranges = [];
+  let start = frozen;
+  for (let end = start + 1; end <= nodes.length; end++) {
+    if (end === nodes.length || replayGenerations && nodes[end].generation !== nodes[start].generation) {
+      ranges.push({ start, end });
+      start = end;
+    }
+  }
+  for (const { start: start2, end } of ranges) {
+    for (let index = start2; index < end; index++) {
+      const later = nodes[index];
+      const laterProduced = expanded.get(later.id).produced;
+      if (laterProduced.length === 0) continue;
+      const matches = candidates(laterProduced);
+      work += matches.length + laterProduced.length;
+      if (work >= nextYield) yield* checkpoint;
+      for (const before of matches) {
+        if (before >= index) break;
+        pairs++;
+        work += 32;
+        if (work >= nextYield || pairs > 25e4) yield* checkpoint;
+        const earlier = nodes[before];
+        const earlierProduced = expanded.get(earlier.id).produced;
+        work += earlierProduced.length * laterProduced.length;
+        if (work >= nextYield) yield* checkpoint;
+        const paths = overlap(earlierProduced, laterProduced);
+        if (paths.length === 0) continue;
+        if (yield* reaches(later.id, earlier.id)) continue;
+        const strategy = pairStrategy(earlier.strategy, later.strategy);
+        const runtime = pairRuntime(earlier.runtime, later.runtime);
+        if (strategy === "fail") {
+          return yield* refuse(
+            "overlap_forbidden",
+            `Nodes ${earlier.id} and ${later.id} both write ${paths.join(", ")}`
+          );
+        }
+        const annotation = (other) => ({ with: other, paths, strategy, runtime });
+        if (before >= start2) {
+          const previous2 = conflicts.get(earlier.id) ?? [];
+          previous2.push(annotation(later.id));
+          conflicts.set(earlier.id, previous2);
+        }
+        const previous = conflicts.get(later.id) ?? [];
+        previous.push(annotation(earlier.id));
+        conflicts.set(later.id, previous);
+        if (strategy === "serialize") {
+          const added = ordering.get(later.id) ?? [];
+          added.push(earlier.id);
+          ordering.set(later.id, added);
+          yield* addEdge(later.id, earlier.id);
+        }
+      }
+    }
+    for (let index = start2; index < end; index++) {
+      const reader = nodes[index];
+      const reads = expanded.get(reader.id).reads;
+      if (reads.length === 0) continue;
+      const matches = candidates(reads);
+      work += matches.length + reads.length;
+      if (work >= nextYield) yield* checkpoint;
+      for (const writerIndex of matches) {
+        if (writerIndex >= end) break;
+        pairs++;
+        work += 32;
+        if (work >= nextYield || pairs > 25e4) yield* checkpoint;
+        const writer = nodes[writerIndex];
+        if (writer.id === reader.id) continue;
+        const produced = expanded.get(writer.id).produced;
+        work += reads.length * produced.length;
+        if (work >= nextYield) yield* checkpoint;
+        const paths = readOverlap(reads, produced);
+        if (paths.length === 0) continue;
+        if (yield* reaches(reader.id, writer.id)) continue;
+        if (yield* reaches(writer.id, reader.id)) {
+          if ((yield* route(writer.id, reader.id, declaredEdges)) !== void 0) continue;
+          const contradiction = yield* route(writer.id, reader.id);
+          return yield* refuse(
+            "cycle",
+            `Plan cycle: node ${reader.id} reads ${paths.join(", ")}, which node ${writer.id} produces, so ${reader.id} must follow ${writer.id}, but ${writer.id} already depends on ${reader.id} through ${contradiction.join(" -> ")}`
+          );
+        }
+        const added = ordering.get(reader.id) ?? [];
+        added.push(writer.id);
+        ordering.set(reader.id, added);
+        yield* addEdge(reader.id, writer.id);
+      }
+    }
+  }
+  return { conflicts, ordering };
+});
+//# sourceMappingURL=ConflictAnnotation.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/ConflictAnnotation.ts"],
+  "sourcesContent": ["/**\n * The compiler's effect analysis: which writers conflict, and which readers\n * must wait for a producer. Its vocabulary is pairs of declared effects; it\n * never re-keys a node, because ordering is not key material.\n *\n * @since 0.1.0\n * @private\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as FileSet from \"../FileSet.ts\"\nimport * as KeyMaterial from \"../KeyMaterial.ts\"\nimport type * as Plan from \"../Plan.ts\"\nimport * as EffectCandidates from \"./EffectCandidates.ts\"\n\n/**\n * What {@link annotate} found, by node id and in discovery order: the conflict\n * annotations a node carries and the ordering edges it gains. A frozen node\n * never appears, because its row is never rewritten.\n *\n * @private\n */\ninterface Annotations {\n  readonly conflicts: ReadonlyMap<string, ReadonlyArray<Plan.ConflictAnnotation>>\n  readonly ordering: ReadonlyMap<string, ReadonlyArray<string>>\n}\n\n/**\n * A graph the analysis refuses, in the fields a `PlanError` carries.\n *\n * @private\n */\ninterface Refusal {\n  readonly code: \"cycle\" | \"graph_too_large\" | \"overlap_forbidden\"\n  readonly message: string\n}\n\n/** @private */\nconst refuse = (code: Refusal[\"code\"], message: string) => Effect.fail<Refusal>({ code, message })\n\n/**\n * Resolves the pair's verdict. `fail` dominates \u2014 a flow that promised\n * disjointness must not be quietly serialized \u2014 then `lane`, because \"when\n * either writer requests `lane`, both receive lane annotations\"; `serialize`\n * is the default whenever an overlap is detected at all.\n *\n * @private\n */\nconst pairStrategy = (left: Plan.PairStrategy, right: Plan.PairStrategy): Plan.PairStrategy =>\n  left === \"fail\" || right === \"fail\" ? \"fail\" : left === \"lane\" || right === \"lane\" ? \"lane\" : \"serialize\"\n\n/**\n * `stop-merge` dominates for the same reason `lane` does: it is the strategy a\n * declaration opts into, and a pair cannot half-merge.\n *\n * @private\n */\nconst pairRuntime = (left: Plan.RuntimeStrategy, right: Plan.RuntimeStrategy): Plan.RuntimeStrategy =>\n  left === \"stop-merge\" || right === \"stop-merge\" ? \"stop-merge\" : \"delay-rebase\"\n\n/**\n * Every path a node mutates. A removal moves a path's content exactly as a\n * write does \u2014 a reader that runs before it sees different bytes than one that\n * runs after \u2014 so both passes below treat the two as one set.\n *\n * @private\n */\nconst producedPaths = (effects: Plan.NodeEffects): ReadonlyArray<FileSet.Entry> => [\n  ...FileSet.expand(effects.writes),\n  ...effects.removes ?? []\n]\n\n/**\n * How an annotation and a refusal name one declared entry.\n *\n * @private\n */\nconst describe = (entry: FileSet.Entry): string =>\n  typeof entry === \"string\" ? entry : entry._tag === \"TreeArtifact\" ? entry.path : entry.include.join(\",\")\n\n/** @private */\nconst overlap = (\n  left: ReadonlyArray<FileSet.Entry>,\n  right: ReadonlyArray<FileSet.Entry>\n): ReadonlyArray<string> =>\n  left.flatMap((leftEntry) =>\n    right.some((rightEntry) => FileSet.overlaps(leftEntry, rightEntry)) ? [describe(leftEntry)] : []\n  )\n\n/**\n * The read declarations of one node that a writer's produced set covers. The\n * conflict pass compares write sets against write sets, so this relation is\n * the one it cannot see. Rendered the way {@link overlap} renders a write,\n * because a refusal names them.\n *\n * @private\n */\nconst readOverlap = (\n  reads: ReadonlyArray<FileSet.ReadEntry>,\n  produced: ReadonlyArray<FileSet.Entry>\n): ReadonlyArray<string> =>\n  reads.flatMap((entry) => produced.some((output) => FileSet.overlaps(entry, output)) ? [describe(entry)] : [])\n\n/**\n * Two passes over the graph.\n *\n * The first detects write overlaps and annotates the conflicting pair, adding\n * the ordering edge a `serialize` verdict implies. Nodes already ordered by a\n * dependency path are not conflicts.\n *\n * The second adds reader-after-writer edges: a node that reads a path another\n * node writes is ordered behind its producer. That pair is not a conflict,\n * because nothing needs annotating and no strategy applies. It is a missing\n * edge, so only `dependsOn` grows. When the graph already orders the producer\n * behind its reader by explicit material dependencies, the reader consumes\n * the earlier version. An opposing inferred ordering still fails with `cycle`.\n *\n * Nodes are visited in plan order, so a `serialize` edge always points from\n * the earlier declaration to the later one and can never close a cycle. The\n * first `frozen` nodes were recorded by an earlier generation: append-only\n * means their rows are never rewritten, so a pair discovered during\n * elaboration is annotated on the NEW node only \u2014 which is also the node the\n * ordering edge lands on, and the annotation names the other side either way.\n * `replayGenerations` re-derives a recorded plan one generation at a time\n * under that same rule.\n *\n * @since 0.1.0\n * @private\n */\nexport const annotate = (\n  nodes: ReadonlyArray<Plan.PlanNode>,\n  frozen: number,\n  replayGenerations: boolean\n): Effect.Effect<Annotations, Refusal> =>\n  Effect.gen(function*() {\n    const expanded = new Map(nodes.map((node) => [node.id, {\n      produced: producedPaths(node.effects),\n      reads: FileSet.expandReads(node.effects.reads)\n    }]))\n    const candidates = EffectCandidates.make(nodes.map((node) => expanded.get(node.id)!.produced))\n    const conflicts = new Map<string, Array<Plan.ConflictAnnotation>>()\n    const ordering = new Map<string, Array<string>>()\n    const edges = new Map(nodes.map((node) => [node.id, new Set(node.dependsOn)]))\n    // Keep declaration sequencing separate from inferred ordering, including\n    // for frozen generations whose `dependsOn` already contains inferred edges.\n    const declaredEdges = new Map(nodes.map((node) => [node.id, KeyMaterial.dependencies(node.material)]))\n    // One index and mutable graph serve every replayed generation. Future\n    // producers are filtered at the generation boundary, never re-indexed.\n    const ordinals = new Map(nodes.map((node, index) => [node.id, index]))\n    const dependents = new Map(nodes.map((node) => [node.id, new Set<string>()]))\n    for (const node of nodes) {\n      for (const dependency of node.dependsOn) dependents.get(dependency)!.add(node.id)\n    }\n    const words = Math.ceil(nodes.length / 32)\n    const ancestors = new Map<string, Uint32Array>()\n    // Charge a pair for bookkeeping as well as its path comparisons. The\n    // separate pair ceiling also bounds persisted annotations and edges.\n    let work = 0\n    let pairs = 0\n    let nextYield = 2_048\n    const checkpoint = Effect.gen(function*() {\n      if (work > 10_000_000 || pairs > 250_000) {\n        return yield* refuse(\n          \"graph_too_large\",\n          \"Plan effect analysis exceeds its work budget (10000000 work units or 250000 candidate pairs)\"\n        )\n      }\n      nextYield = Math.min(work + 2_048, 10_000_001)\n      yield* Effect.yieldNow\n    })\n    // Cache transitive ancestors as bitsets. Adding an edge updates its source\n    // immediately and invalidates only cached dependents. In particular, dense\n    // writers never walk the growing dependency DAG for each conflicting pair.\n    const closure = (id: string): Effect.Effect<Uint32Array, Refusal> =>\n      Effect.gen(function*() {\n        const cached = ancestors.get(id)\n        if (cached !== undefined) return cached\n        const frame = (id: string) => {\n          const bits = new Uint32Array(words)\n          const ordinal = ordinals.get(id)!\n          bits[ordinal >>> 5]! |= 1 << (ordinal & 31)\n          return { id, bits, dependencies: Array.from(edges.get(id)!), next: 0 }\n        }\n        const stack = [frame(id)]\n        while (stack.length > 0) {\n          const current = stack[stack.length - 1]!\n          const dependency = current.dependencies[current.next]\n          if (dependency === undefined) {\n            ancestors.set(current.id, current.bits)\n            stack.pop()\n            continue\n          }\n          const bits = ancestors.get(dependency)\n          if (bits === undefined) {\n            stack.push(frame(dependency))\n            continue\n          }\n          for (let word = 0; word < words; word++) {\n            current.bits[word]! |= bits[word]!\n            if (++work >= nextYield) yield* checkpoint\n          }\n          current.next++\n        }\n        return ancestors.get(id)!\n      })\n    const reaches = (from: string, to: string) =>\n      Effect.gen(function*() {\n        const bits = yield* closure(from)\n        const ordinal = ordinals.get(to)!\n        return (bits[ordinal >>> 5]! & (1 << (ordinal & 31))) !== 0\n      })\n    const addEdge = (from: string, to: string) =>\n      Effect.gen(function*() {\n        const source = yield* closure(from)\n        const target = yield* closure(to)\n        for (let word = 0; word < words; word++) {\n          source[word]! |= target[word]!\n          if (++work >= nextYield) yield* checkpoint\n        }\n        const stack = [from]\n        while (stack.length > 0) {\n          for (const dependent of dependents.get(stack.pop()!)!) {\n            if (++work >= nextYield) yield* checkpoint\n            if (!ancestors.delete(dependent)) continue\n            stack.push(dependent)\n          }\n        }\n        edges.get(from)!.add(to)\n        dependents.get(to)!.add(from)\n      })\n    // Routes are only needed for explicit version sequencing and a cycle's\n    // diagnostic. Bound and yield these walks too.\n    const route = (\n      from: string,\n      to: string,\n      graph: ReadonlyMap<string, Iterable<string>> = edges\n    ): Effect.Effect<ReadonlyArray<string> | undefined, Refusal> =>\n      Effect.gen(function*() {\n        const arrivedFrom = new Map<string, string>()\n        const seen = new Set<string>([from])\n        const stack = [from]\n        while (stack.length > 0) {\n          const current = stack.pop()!\n          if (current === to) {\n            const chain = [current]\n            for (let step = arrivedFrom.get(current); step !== undefined; step = arrivedFrom.get(step)) {\n              chain.push(step)\n            }\n            return chain.reverse()\n          }\n          for (const next of graph.get(current)!) {\n            if (++work >= nextYield) yield* checkpoint\n            if (seen.has(next)) continue\n            seen.add(next)\n            arrivedFrom.set(next, current)\n            stack.push(next)\n          }\n        }\n        return undefined\n      })\n    const ranges: Array<{ start: number; end: number }> = []\n    let start = frozen\n    for (let end = start + 1; end <= nodes.length; end++) {\n      if (end === nodes.length || (replayGenerations && nodes[end]!.generation !== nodes[start]!.generation)) {\n        ranges.push({ start, end })\n        start = end\n      }\n    }\n    for (const { start, end } of ranges) {\n      for (let index = start; index < end; index++) {\n        const later = nodes[index]!\n        const laterProduced = expanded.get(later.id)!.produced\n        if (laterProduced.length === 0) continue\n        const matches = candidates(laterProduced)\n        work += matches.length + laterProduced.length\n        if (work >= nextYield) yield* checkpoint\n        for (const before of matches) {\n          if (before >= index) break\n          pairs++\n          work += 32\n          if (work >= nextYield || pairs > 250_000) yield* checkpoint\n          const earlier = nodes[before]!\n          const earlierProduced = expanded.get(earlier.id)!.produced\n          work += earlierProduced.length * laterProduced.length\n          if (work >= nextYield) yield* checkpoint\n          const paths = overlap(earlierProduced, laterProduced)\n          if (paths.length === 0) continue\n          if (yield* reaches(later.id, earlier.id)) continue\n          const strategy = pairStrategy(earlier.strategy, later.strategy)\n          const runtime = pairRuntime(earlier.runtime, later.runtime)\n          if (strategy === \"fail\") {\n            return yield* refuse(\n              \"overlap_forbidden\",\n              `Nodes ${earlier.id} and ${later.id} both write ${paths.join(\", \")}`\n            )\n          }\n          const annotation = (other: string): Plan.ConflictAnnotation => ({ with: other, paths, strategy, runtime })\n          if (before >= start) {\n            const previous = conflicts.get(earlier.id) ?? []\n            previous.push(annotation(later.id))\n            conflicts.set(earlier.id, previous)\n          }\n          const previous = conflicts.get(later.id) ?? []\n          previous.push(annotation(earlier.id))\n          conflicts.set(later.id, previous)\n          if (strategy === \"serialize\") {\n            const added = ordering.get(later.id) ?? []\n            added.push(earlier.id)\n            ordering.set(later.id, added)\n            yield* addEdge(later.id, earlier.id)\n          }\n        }\n      }\n      // Reader-after-writer. A node that READS a path another node WRITES was\n      // ordered by nothing: the pass above compares write sets against write\n      // sets, so reader and writer could be admitted in the same wavefront\n      // round. The reader then measures pre-producer bytes and \u2014 because the\n      // dispatch key honestly folds the digest it measured \u2014 caches that wrong\n      // execution as a legitimate one. `PlanScheduler.measure` already assumes\n      // \"their preceding producer has settled\"; this pass is what makes that\n      // assumption true. Explicit read-before-write sequencing instead consumes\n      // an earlier version: a source input, or another preceding writer's output.\n      //\n      // Ordering only, exactly like a `serialize` edge: it enters `dependsOn`\n      // and never key material, because the reader computes the same result\n      // either way and its content dependence is already keyed by the hermetic\n      // boundary digests measured at dispatch.\n      for (let index = start; index < end; index++) {\n        const reader = nodes[index]!\n        // Append-only: a frozen node's row is never rewritten, so the edge lands\n        // on the new node only \u2014 the same rule the conflict pass follows.\n        const reads = expanded.get(reader.id)!.reads\n        if (reads.length === 0) continue\n        const matches = candidates(reads)\n        work += matches.length + reads.length\n        if (work >= nextYield) yield* checkpoint\n        for (const writerIndex of matches) {\n          if (writerIndex >= end) break\n          pairs++\n          work += 32\n          if (work >= nextYield || pairs > 250_000) yield* checkpoint\n          const writer = nodes[writerIndex]!\n          if (writer.id === reader.id) continue\n          const produced = expanded.get(writer.id)!.produced\n          work += reads.length * produced.length\n          if (work >= nextYield) yield* checkpoint\n          const paths = readOverlap(reads, produced)\n          if (paths.length === 0) continue\n          // Already ordered, by a material edge, a serialize edge, or a path\n          // through either.\n          if (yield* reaches(reader.id, writer.id)) continue\n          // Explicit sequencing selects the version being read. Do not reverse\n          // it just because a later node writes the same path. Only declared\n          // Ref/Pending paths establish this intent; a serialize edge or an\n          // earlier inferred producer edge cannot silently select old bytes.\n          if (yield* reaches(writer.id, reader.id)) {\n            if ((yield* route(writer.id, reader.id, declaredEdges)) !== undefined) continue\n            const contradiction = (yield* route(writer.id, reader.id))!\n            return yield* refuse(\n              \"cycle\",\n              `Plan cycle: node ${reader.id} reads ${paths.join(\", \")}, which node ${writer.id} produces, ` +\n                `so ${reader.id} must follow ${writer.id}, but ${writer.id} already depends on ${reader.id} ` +\n                `through ${contradiction.join(\" -> \")}`\n            )\n          }\n          const added = ordering.get(reader.id) ?? []\n          added.push(writer.id)\n          ordering.set(reader.id, added)\n          yield* addEdge(reader.id, writer.id)\n        }\n      }\n    }\n    return { conflicts, ordering }\n  })\n"],
+  "mappings": "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",
+  "names": ["id", "start", "previous"]
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Rebuildable candidate index for the compiler's existing overlap predicate.
+ * Exact paths and tree prefixes share a trie keyed by case-folded segments, the
+ * form FileSet.overlaps compares. A plain string is a literal path there, even
+ * one holding `*`. Globs stay conservative: their exclusions and pair semantics
+ * are decided by FileSet.overlaps, never here.
+ * Nothing in this index becomes persisted plan or key material.
+ * @since 0.1.0
+ * @private
+ */
+import * as FileSet from "../FileSet.ts";
+/**
+ * Selects possible producers in declaration order; callers retain the final
+ * FileSet.overlaps check for every selected pair.
+ * @since 0.1.0
+ * @private
+ */
+export declare const make: (produced: ReadonlyArray<ReadonlyArray<FileSet.Entry>>) => (entries: ReadonlyArray<FileSet.Entry>) => ReadonlyArray<number>;
+//# sourceMappingURL=EffectCandidates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EffectCandidates.d.ts","sourceRoot":"","sources":["../../../src/internal/EffectCandidates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,OAAO,MAAM,eAAe,CAAA;AAgBxC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,UAAU,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MA0BhE,SAAS,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,KAAG,aAAa,CAAC,MAAM,CA6BrE,CAAA"}

package/dist/cjs/internal/EffectCandidates.js

@@ -0,0 +1,92 @@
+"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 EffectCandidates_exports = {};
+__export(EffectCandidates_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(EffectCandidates_exports);
+var FileSet = __toESM(require("../FileSet.js"), 1);
+const branch = () => ({ children: /* @__PURE__ */ new Map(), exact: /* @__PURE__ */ new Set(), trees: /* @__PURE__ */ new Set() });
+const add = (target, values) => {
+  for (const value of values) target.add(value);
+};
+const patternLike = (entry) => typeof entry !== "string" && entry._tag === "Glob";
+const ordered = (values) => Array.from(values).sort((left, right) => left - right);
+const make = (produced) => {
+  const root = branch();
+  const all = /* @__PURE__ */ new Set();
+  const globs = /* @__PURE__ */ new Set();
+  for (let owner = 0; owner < produced.length; owner++) {
+    for (const entry of produced[owner]) {
+      all.add(owner);
+      if (patternLike(entry)) {
+        globs.add(owner);
+        continue;
+      }
+      const path = typeof entry === "string" ? entry : entry.path;
+      let current = root;
+      for (const segment of FileSet.folded(path).split("/")) {
+        let child = current.children.get(segment);
+        if (child === void 0) {
+          child = branch();
+          current.children.set(segment, child);
+        }
+        current = child;
+      }
+      const owners = typeof entry === "string" ? current.exact : current.trees;
+      owners.add(owner);
+    }
+  }
+  return (entries) => {
+    const found = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (patternLike(entry)) return ordered(all);
+      add(found, globs);
+      const path = typeof entry === "string" ? entry : entry.path;
+      let current = root;
+      for (const segment of FileSet.folded(path).split("/")) {
+        current = current.children.get(segment);
+        if (current === void 0) break;
+        add(found, current.trees);
+      }
+      if (current === void 0) continue;
+      add(found, current.exact);
+      if (typeof entry === "string") continue;
+      const stack = Array.from(current.children.values());
+      while (stack.length > 0) {
+        const descendant = stack.pop();
+        add(found, descendant.exact);
+        add(found, descendant.trees);
+        for (const child of descendant.children.values()) stack.push(child);
+      }
+    }
+    return ordered(found);
+  };
+};
+//# sourceMappingURL=EffectCandidates.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/EffectCandidates.ts"],
+  "sourcesContent": ["/**\n * Rebuildable candidate index for the compiler's existing overlap predicate.\n * Exact paths and tree prefixes share a trie keyed by case-folded segments, the\n * form FileSet.overlaps compares. A plain string is a literal path there, even\n * one holding `*`. Globs stay conservative: their exclusions and pair semantics\n * are decided by FileSet.overlaps, never here.\n * Nothing in this index becomes persisted plan or key material.\n * @since 0.1.0\n * @private\n */\n\nimport * as FileSet from \"../FileSet.ts\"\n\ninterface Branch {\n  readonly children: Map<string, Branch>\n  readonly exact: Set<number>\n  readonly trees: Set<number>\n}\n\nconst branch = (): Branch => ({ children: new Map(), exact: new Set(), trees: new Set() })\nconst add = (target: Set<number>, values: ReadonlySet<number>): void => {\n  for (const value of values) target.add(value)\n}\n/** A Glob has no single trie position, so it stays conservative. */\nconst patternLike = (entry: FileSet.Entry): entry is FileSet.Glob => typeof entry !== \"string\" && entry._tag === \"Glob\"\nconst ordered = (values: ReadonlySet<number>): Array<number> => Array.from(values).sort((left, right) => left - right)\n\n/**\n * Selects possible producers in declaration order; callers retain the final\n * FileSet.overlaps check for every selected pair.\n * @since 0.1.0\n * @private\n */\nexport const make = (produced: ReadonlyArray<ReadonlyArray<FileSet.Entry>>) => {\n  const root = branch()\n  const all = new Set<number>()\n  const globs = new Set<number>()\n  for (let owner = 0; owner < produced.length; owner++) {\n    for (const entry of produced[owner]!) {\n      all.add(owner)\n      if (patternLike(entry)) {\n        globs.add(owner)\n        continue\n      }\n      const path = typeof entry === \"string\" ? entry : entry.path\n      let current = root\n      for (const segment of FileSet.folded(path).split(\"/\")) {\n        let child = current.children.get(segment)\n        if (child === undefined) {\n          child = branch()\n          current.children.set(segment, child)\n        }\n        current = child\n      }\n      const owners = typeof entry === \"string\" ? current.exact : current.trees\n      owners.add(owner)\n    }\n  }\n\n  return (entries: ReadonlyArray<FileSet.Entry>): ReadonlyArray<number> => {\n    const found = new Set<number>()\n    for (const entry of entries) {\n      // A glob can overlap every other glob/tree; literal matches and\n      // exclusions remain the final predicate's responsibility as well.\n      if (patternLike(entry)) return ordered(all)\n      add(found, globs)\n      const path = typeof entry === \"string\" ? entry : entry.path\n      let current: Branch | undefined = root\n      for (const segment of FileSet.folded(path).split(\"/\")) {\n        current = current.children.get(segment)\n        if (current === undefined) break\n        add(found, current.trees)\n      }\n      if (current === undefined) continue\n      add(found, current.exact)\n      if (typeof entry === \"string\") continue\n      const stack = Array.from(current.children.values())\n      while (stack.length > 0) {\n        const descendant = stack.pop()!\n        add(found, descendant.exact)\n        add(found, descendant.trees)\n        for (const child of descendant.children.values()) stack.push(child)\n      }\n    }\n    // Original declaration order controls annotations, conflict precedence,\n    // and cycle diagnostics, irrespective of trie or Set traversal order.\n    return ordered(found)\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,cAAyB;AAQzB,MAAM,SAAS,OAAe,EAAE,UAAU,oBAAI,IAAI,GAAG,OAAO,oBAAI,IAAI,GAAG,OAAO,oBAAI,IAAI,EAAE;AACxF,MAAM,MAAM,CAAC,QAAqB,WAAsC;AACtE,aAAW,SAAS,OAAQ,QAAO,IAAI,KAAK;AAC9C;AAEA,MAAM,cAAc,CAAC,UAAgD,OAAO,UAAU,YAAY,MAAM,SAAS;AACjH,MAAM,UAAU,CAAC,WAA+C,MAAM,KAAK,MAAM,EAAE,KAAK,CAAC,MAAM,UAAU,OAAO,KAAK;AAQ9G,MAAM,OAAO,CAAC,aAA0D;AAC7E,QAAM,OAAO,OAAO;AACpB,QAAM,MAAM,oBAAI,IAAY;AAC5B,QAAM,QAAQ,oBAAI,IAAY;AAC9B,WAAS,QAAQ,GAAG,QAAQ,SAAS,QAAQ,SAAS;AACpD,eAAW,SAAS,SAAS,KAAK,GAAI;AACpC,UAAI,IAAI,KAAK;AACb,UAAI,YAAY,KAAK,GAAG;AACtB,cAAM,IAAI,KAAK;AACf;AAAA,MACF;AACA,YAAM,OAAO,OAAO,UAAU,WAAW,QAAQ,MAAM;AACvD,UAAI,UAAU;AACd,iBAAW,WAAW,QAAQ,OAAO,IAAI,EAAE,MAAM,GAAG,GAAG;AACrD,YAAI,QAAQ,QAAQ,SAAS,IAAI,OAAO;AACxC,YAAI,UAAU,QAAW;AACvB,kBAAQ,OAAO;AACf,kBAAQ,SAAS,IAAI,SAAS,KAAK;AAAA,QACrC;AACA,kBAAU;AAAA,MACZ;AACA,YAAM,SAAS,OAAO,UAAU,WAAW,QAAQ,QAAQ,QAAQ;AACnE,aAAO,IAAI,KAAK;AAAA,IAClB;AAAA,EACF;AAEA,SAAO,CAAC,YAAiE;AACvE,UAAM,QAAQ,oBAAI,IAAY;AAC9B,eAAW,SAAS,SAAS;AAG3B,UAAI,YAAY,KAAK,EAAG,QAAO,QAAQ,GAAG;AAC1C,UAAI,OAAO,KAAK;AAChB,YAAM,OAAO,OAAO,UAAU,WAAW,QAAQ,MAAM;AACvD,UAAI,UAA8B;AAClC,iBAAW,WAAW,QAAQ,OAAO,IAAI,EAAE,MAAM,GAAG,GAAG;AACrD,kBAAU,QAAQ,SAAS,IAAI,OAAO;AACtC,YAAI,YAAY,OAAW;AAC3B,YAAI,OAAO,QAAQ,KAAK;AAAA,MAC1B;AACA,UAAI,YAAY,OAAW;AAC3B,UAAI,OAAO,QAAQ,KAAK;AACxB,UAAI,OAAO,UAAU,SAAU;AAC/B,YAAM,QAAQ,MAAM,KAAK,QAAQ,SAAS,OAAO,CAAC;AAClD,aAAO,MAAM,SAAS,GAAG;AACvB,cAAM,aAAa,MAAM,IAAI;AAC7B,YAAI,OAAO,WAAW,KAAK;AAC3B,YAAI,OAAO,WAAW,KAAK;AAC3B,mBAAW,SAAS,WAAW,SAAS,OAAO,EAAG,OAAM,KAAK,KAAK;AAAA,MACpE;AAAA,IACF;AAGA,WAAO,QAAQ,KAAK;AAAA,EACtB;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,34 @@
+/**
+ * The inert JSON mirror of a value: what `JSON.stringify` would see, as data.
+ *
+ * The AST stores payloads this way, the plan compiler stores key material this
+ * way, and a plan diff compares declarations this way, so all three share the
+ * one walk. A planned value is the only member with no JSON meaning of its
+ * own, and each caller decides what it becomes.
+ *
+ * @since 0.1.0
+ * @private
+ */
+import * as Planned from "../Planned.ts";
+/**
+ * Clones the JSON mirror of the input, so {@link module:StepKey.content} over
+ * the clone and the input produce the same key and the clone holds only inert
+ * JSON data. The walk uses an explicit stack, memoizes shared references and
+ * cycles, honors callable `toJSON`, omits object members without a JSON
+ * representation, and writes `null` for those values in arrays.
+ *
+ * `toJSON` receives the key canonical serialization passes it: the member
+ * name, the array index, or `""` at the root. Its replacement is therefore
+ * memoized per source and key, since one shared source may serialize
+ * differently at two positions. A source met again inside its own
+ * replacement reuses that replacement, so a cycle through `toJSON` clones as
+ * a cycle whatever key it recurs at.
+ *
+ * A planned value becomes whatever `plannedValue` returns for it. Refusals
+ * throw a {@link GraphBuildError} naming the member's path.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const jsonMirror: (input: unknown, plannedValue: (value: unknown, reference: Planned.Reference) => unknown) => unknown;
+//# sourceMappingURL=JsonMirror.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JsonMirror.d.ts","sourceRoot":"","sources":["../../../src/internal/JsonMirror.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,OAAO,MAAM,eAAe,CAAA;AAqFxC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,OAAO,EACd,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,KAAK,OAAO,KACtE,OAqIF,CAAA"}