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

package/dist/cjs/FileSet.js

@@ -0,0 +1,191 @@
+"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 FileSet_exports = {};
+__export(FileSet_exports, {
+  BoundaryMode: () => BoundaryMode,
+  Declaration: () => Declaration,
+  Entry: () => Entry,
+  Filegroup: () => Filegroup,
+  Glob: () => Glob,
+  Pattern: () => Pattern,
+  ReadDeclaration: () => ReadDeclaration,
+  ReadEntry: () => ReadEntry,
+  ReadFilegroup: () => ReadFilegroup,
+  TreeArtifact: () => TreeArtifact,
+  canonical: () => canonical,
+  expand: () => expand,
+  expandReads: () => expandReads,
+  folded: () => folded,
+  isGlob: () => isGlob,
+  isTreeArtifact: () => isTreeArtifact,
+  makeFilegroup: () => makeFilegroup,
+  matchesGlob: () => matchesGlob,
+  matchesPattern: () => matchesPattern,
+  overlaps: () => overlaps,
+  workspaceRelative: () => workspaceRelative
+});
+module.exports = __toCommonJS(FileSet_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+const BoundaryMode = Schema.Literals(["hard", "expected"]);
+const canonical = (path) => path.replaceAll("\\", "/").normalize("NFC");
+const folded = (path) => canonical(path).toUpperCase().normalize("NFC");
+const Pattern = Schema.NonEmptyString.check(
+  Schema.makeFilter(
+    (pattern) => workspaceRelative(pattern) || "file patterns must be workspace-relative and cannot traverse upward",
+    { title: "workspaceRelativePattern" }
+  )
+);
+const workspaceRelative = (pattern) => {
+  for (let index = 0; index < pattern.length; index++) {
+    const code = pattern.charCodeAt(index);
+    if (code <= 31 || code === 127) return false;
+  }
+  if (pattern.startsWith("/")) return false;
+  const segments = canonical(pattern).split("/");
+  if (/^[A-Za-z]:/.test(segments[0]) || segments[0].endsWith(":")) return false;
+  return segments.every((segment) => segment !== ".." && segment !== "." && segment !== "");
+};
+const Glob = Schema.TaggedStruct("Glob", {
+  include: Schema.NonEmptyArray(Pattern),
+  exclude: Schema.optional(Schema.Array(Pattern))
+});
+const TreeArtifact = Schema.TaggedStruct("TreeArtifact", {
+  path: Pattern
+});
+const Entry = Schema.Union([Pattern, Glob, TreeArtifact]);
+const ReadEntry = Schema.Union([Pattern, Glob]);
+const Filegroup = Schema.TaggedStruct("Filegroup", {
+  name: Schema.NonEmptyString,
+  entries: Schema.Array(Entry)
+});
+const ReadFilegroup = Schema.TaggedStruct("Filegroup", {
+  name: Schema.NonEmptyString,
+  entries: Schema.Array(ReadEntry)
+});
+const Declaration = Schema.Union([Entry, Filegroup]);
+const ReadDeclaration = Schema.Union([ReadEntry, ReadFilegroup]);
+const makeFilegroup = (name, entries) => ({
+  _tag: "Filegroup",
+  name,
+  entries
+});
+const expand = (declarations) => declarations.flatMap(
+  (declaration) => typeof declaration !== "string" && declaration._tag === "Filegroup" ? declaration.entries : [declaration]
+);
+const expandReads = (declarations) => declarations.flatMap(
+  (declaration) => typeof declaration !== "string" && declaration._tag === "Filegroup" ? declaration.entries : [declaration]
+);
+const isGlob = (value) => typeof value === "object" && value !== null && "_tag" in value && value._tag === "Glob";
+const isTreeArtifact = (value) => typeof value === "object" && value !== null && "_tag" in value && value._tag === "TreeArtifact";
+const literalSearch = (literal) => {
+  const fallback = new Uint32Array(literal.length);
+  let matched = 0;
+  for (let index = 1; index < literal.length; index++) {
+    while (matched > 0 && literal[index] !== literal[matched]) matched = fallback[matched - 1];
+    if (literal[index] === literal[matched]) matched++;
+    fallback[index] = matched;
+  }
+  return (path, start, end) => {
+    let matched2 = 0;
+    for (let index = start; index < end; index++) {
+      while (matched2 > 0 && path[index] !== literal[matched2]) matched2 = fallback[matched2 - 1];
+      if (path[index] === literal[matched2]) matched2++;
+      if (matched2 === literal.length) return index + 1;
+    }
+    return -1;
+  };
+};
+const segmentMatcher = (segment) => {
+  const chunks = segment.split(/\*+/);
+  const prefix = chunks.shift();
+  if (chunks.length === 0) return (path) => path === prefix;
+  const suffix = chunks.pop();
+  const searches = chunks.map(literalSearch);
+  return (path) => {
+    const end = path.length - suffix.length;
+    if (prefix.length > end || !path.startsWith(prefix) || !path.endsWith(suffix)) return false;
+    let position = prefix.length;
+    for (const search of searches) {
+      position = search(path, position, end);
+      if (position === -1) return false;
+    }
+    return true;
+  };
+};
+const patternMatchers = /* @__PURE__ */ new Map();
+const patternMatcher = (pattern) => {
+  const key = canonical(pattern);
+  const cached = patternMatchers.get(key);
+  if (cached !== void 0) return cached;
+  const segments = key.split("/").map((segment) => segment === "**" ? void 0 : segmentMatcher(segment));
+  const matcher = (path) => {
+    const parts = path.split("/");
+    let next = new Uint8Array(parts.length + 1);
+    next[parts.length] = 1;
+    for (let index = segments.length - 1; index >= 0; index--) {
+      const segment = segments[index];
+      const current = new Uint8Array(parts.length + 1);
+      for (let part = parts.length - 1; part >= 0; part--) {
+        current[part] = segment === void 0 ? Number(
+          index === segments.length - 1 || next[part] === 1 || parts[part] !== "" && current[part + 1] === 1
+        ) : Number(next[part + 1] === 1 && segment(parts[part]));
+      }
+      next = current;
+    }
+    return next[0] === 1;
+  };
+  patternMatchers.set(key, matcher);
+  return matcher;
+};
+const matchesPattern = (pattern, path) => patternMatcher(pattern)(path);
+const matchesGlob = (glob, path) => glob.include.some((pattern) => matchesPattern(pattern, path)) && !(glob.exclude ?? []).some((pattern) => matchesPattern(pattern, path));
+const beneath = (tree, path) => {
+  const root = folded(tree);
+  const inside = folded(path);
+  return inside === root || inside.startsWith(`${root}/`);
+};
+const matchesGlobFolded = (glob, path) => {
+  const inside = folded(path);
+  return glob.include.some((pattern) => matchesPattern(folded(pattern), inside)) && !(glob.exclude ?? []).some((pattern) => matchesPattern(folded(pattern), inside));
+};
+const overlaps = (left, right) => {
+  if (typeof left === "string" && typeof right === "string") return folded(left) === folded(right);
+  if (typeof left === "string" && isGlob(right)) return matchesGlobFolded(right, left);
+  if (isGlob(left) && typeof right === "string") return matchesGlobFolded(left, right);
+  if (isGlob(left) && isGlob(right)) return true;
+  if (isTreeArtifact(left) && typeof right === "string") return beneath(left.path, right);
+  if (typeof left === "string" && isTreeArtifact(right)) return beneath(right.path, left);
+  if (isTreeArtifact(left) && isTreeArtifact(right)) {
+    return beneath(left.path, right.path) || beneath(right.path, left.path);
+  }
+  if (isTreeArtifact(left) && isGlob(right)) return true;
+  if (isGlob(left) && isTreeArtifact(right)) return overlaps(right, left);
+  return true;
+};
+//# sourceMappingURL=FileSet.js.map

package/dist/cjs/FileSet.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/FileSet.ts"],
+  "sourcesContent": ["/**\n * Static filesystem declaration vocabulary shared by planning and execution.\n *\n * Declared paths use `/` as their canonical separator and normalize Unicode\n * to NFC. Workspace-relative paths reject C0 controls (U+0000 through U+001F)\n * and DEL (U+007F), which name nothing a supported filesystem can open. C1\n * controls (U+0080 through U+009F) remain accepted because those bytes are\n * legal in a POSIX file name.\n *\n * @since 0.1.0\n */\n\nimport * as Schema from \"effect/Schema\"\n\n/**\n * How strictly a declared file set is enforced at the boundary.\n *\n * `hard` rejects undeclared access. `expected` records access for validation\n * after execution without requiring the sandbox to reject it immediately.\n *\n * This is the ONE spelling of the pair. `Plan.NodeEffects.boundaryMode` is this\n * schema and so is `@smthrs/flow`'s `Action.BoundaryMode`; the literal used to\n * be written out in all three places.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const BoundaryMode = Schema.Literals([\"hard\", \"expected\"])\n\n/**\n * The value form of {@link BoundaryMode}.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type BoundaryMode = typeof BoundaryMode.Type\n\n/**\n * The canonical spelling of a declared path or pattern: every separator is\n * `/`, and Unicode is normalized to NFC.\n *\n * {@link workspaceRelative} accepts a backslash as a separator, so\n * `dist\\same.js` and `dist/same.js` are two spellings of ONE workspace path.\n * Every exact-path comparison in this module goes through this form, because\n * comparing the raw spellings would let the separator alias defeat overlap\n * detection exactly as `.` segments and empty segments would.\n *\n * @category accessors\n * @since 0.1.0\n * @slop\n */\nexport const canonical = (path: string): string => path.replaceAll(\"\\\\\", \"/\").normalize(\"NFC\")\n\n/**\n * The {@link canonical} spelling with letter case folded away.\n *\n * A case-insensitive filesystem (default macOS APFS, Windows NTFS) opens\n * `src/A.ts` and `src/a.ts` as one file, so static overlap compares this form:\n * two declarations that differ only in case must serialize. Folding goes\n * through upper case because that mapping is context-free, so it folds each\n * character alone and commutes with splitting a path into segments.\n *\n * @category accessors\n * @since 1.0.0-rc.0\n */\nexport const folded = (path: string): string => canonical(path).toUpperCase().normalize(\"NFC\")\n\n/** Workspace-relative glob pattern.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const Pattern = Schema.NonEmptyString.check(\n  Schema.makeFilter(\n    (pattern) => workspaceRelative(pattern) || \"file patterns must be workspace-relative and cannot traverse upward\",\n    { title: \"workspaceRelativePattern\" }\n  )\n)\n\n/**\n * Whether a declared path or pattern stays inside the workspace and names it\n * one way only. Refuses absolute paths (POSIX and drive-letter), upward\n * traversal, and the aliasing forms \u2014 `.` segments, empty segments \u2014 that\n * would let two spellings of one file defeat exact-string overlap detection.\n *\n * @category predicates\n * @since 0.1.0\n * @slop\n */\nexport const workspaceRelative = (pattern: string): boolean => {\n  for (let index = 0; index < pattern.length; index++) {\n    const code = pattern.charCodeAt(index)\n    if (code <= 0x1f || code === 0x7f) return false\n  }\n  if (pattern.startsWith(\"/\")) return false\n  const segments = canonical(pattern).split(\"/\")\n  // `C:foo` is drive-relative on Windows, so any drive-letter prefix escapes.\n  if (/^[A-Za-z]:/.test(segments[0]!) || segments[0]!.endsWith(\":\")) return false\n  return segments.every((segment) => segment !== \"..\" && segment !== \".\" && segment !== \"\")\n}\n\n/** Bazel-style file glob.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const Glob = Schema.TaggedStruct(\"Glob\", {\n  include: Schema.NonEmptyArray(Pattern),\n  exclude: Schema.optional(Schema.Array(Pattern))\n})\n\n/** Bazel-style file glob.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Glob = typeof Glob.Type\n\n/** A directory output captured and replayed as one tree artifact.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const TreeArtifact = Schema.TaggedStruct(\"TreeArtifact\", {\n  path: Pattern\n})\n\n/** A directory output captured and replayed as one tree artifact.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type TreeArtifact = typeof TreeArtifact.Type\n\n/** One leaf of a named filegroup.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const Entry = Schema.Union([Pattern, Glob, TreeArtifact])\n\n/** One leaf of a named filegroup.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Entry = typeof Entry.Type\n\n/** A declaration valid in a read set.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const ReadEntry = Schema.Union([Pattern, Glob])\n\n/** A declaration valid in a read set.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type ReadEntry = typeof ReadEntry.Type\n\n/** A named reusable collection expanded before measurement.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const Filegroup = Schema.TaggedStruct(\"Filegroup\", {\n  name: Schema.NonEmptyString,\n  entries: Schema.Array(Entry)\n})\n\n/** A named reusable collection expanded before measurement.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Filegroup = typeof Filegroup.Type\n\n/** A named read-only collection.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const ReadFilegroup = Schema.TaggedStruct(\"Filegroup\", {\n  name: Schema.NonEmptyString,\n  entries: Schema.Array(ReadEntry)\n})\n\n/** A named read-only collection.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type ReadFilegroup = typeof ReadFilegroup.Type\n\n/** Any declaration accepted by a plan effect set.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const Declaration = Schema.Union([Entry, Filegroup])\n\n/** Any declaration accepted by a plan effect set.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Declaration = typeof Declaration.Type\n\n/** Any declaration accepted by a plan read set.\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const ReadDeclaration = Schema.Union([ReadEntry, ReadFilegroup])\n\n/** Any declaration accepted by a plan read set.\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type ReadDeclaration = typeof ReadDeclaration.Type\n\n/** Creates a named filegroup.\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const makeFilegroup = (name: string, entries: ReadonlyArray<Entry>): Filegroup => ({\n  _tag: \"Filegroup\",\n  name,\n  entries\n})\n\n/** Expands filegroups deterministically, preserving declaration order.\n * @category accessors\n * @since 0.1.0\n * @slop\n */\nexport const expand = (declarations: ReadonlyArray<Declaration>): ReadonlyArray<Entry> =>\n  declarations.flatMap((declaration) =>\n    typeof declaration !== \"string\" && declaration._tag === \"Filegroup\" ? declaration.entries : [declaration]\n  )\n\n/** Expands read filegroups deterministically, preserving declaration order.\n * @category accessors\n * @since 0.1.0\n * @slop\n */\nexport const expandReads = (declarations: ReadonlyArray<ReadDeclaration>): ReadonlyArray<ReadEntry> =>\n  declarations.flatMap((declaration) =>\n    typeof declaration !== \"string\" && declaration._tag === \"Filegroup\" ? declaration.entries : [declaration]\n  )\n\n/** Whether a value is a glob declaration.\n * @category guards\n * @since 0.1.0\n * @slop\n */\nexport const isGlob = (value: unknown): value is Glob =>\n  typeof value === \"object\" && value !== null && \"_tag\" in value && value._tag === \"Glob\"\n\n/** Whether a value is a tree artifact declaration.\n * @category guards\n * @since 0.1.0\n * @slop\n */\nexport const isTreeArtifact = (value: unknown): value is TreeArtifact =>\n  typeof value === \"object\" && value !== null && \"_tag\" in value && value._tag === \"TreeArtifact\"\n\n/** KMP searches a literal without rescanning a long near-matching prefix. */\nconst literalSearch = (literal: string) => {\n  const fallback = new Uint32Array(literal.length)\n  let matched = 0\n  for (let index = 1; index < literal.length; index++) {\n    while (matched > 0 && literal[index] !== literal[matched]) matched = fallback[matched - 1]!\n    if (literal[index] === literal[matched]) matched++\n    fallback[index] = matched\n  }\n  return (path: string, start: number, end: number): number => {\n    let matched = 0\n    for (let index = start; index < end; index++) {\n      while (matched > 0 && path[index] !== literal[matched]) matched = fallback[matched - 1]!\n      if (path[index] === literal[matched]) matched++\n      if (matched === literal.length) return index + 1\n    }\n    return -1\n  }\n}\n\n/** Anchored ends and disjoint literal searches make each segment match linear. */\nconst segmentMatcher = (segment: string): (path: string) => boolean => {\n  const chunks = segment.split(/\\*+/)\n  const prefix = chunks.shift()!\n  if (chunks.length === 0) return (path) => path === prefix\n  const suffix = chunks.pop()!\n  const searches = chunks.map(literalSearch)\n  return (path) => {\n    const end = path.length - suffix.length\n    if (prefix.length > end || !path.startsWith(prefix) || !path.endsWith(suffix)) return false\n    let position = prefix.length\n    for (const search of searches) {\n      position = search(path, position, end)\n      if (position === -1) return false\n    }\n    return true\n  }\n}\n\nconst patternMatchers = new Map<string, (path: string) => boolean>()\n\n/** Compile once per canonical spelling; recursive segments use no backtracking. */\nconst patternMatcher = (pattern: string): (path: string) => boolean => {\n  const key = canonical(pattern)\n  const cached = patternMatchers.get(key)\n  if (cached !== undefined) return cached\n  const segments = key.split(\"/\").map((segment) => segment === \"**\" ? undefined : segmentMatcher(segment))\n  const matcher = (path: string): boolean => {\n    const parts = path.split(\"/\")\n    // Suffix membership: next[j] says the remaining pattern matches parts[j..].\n    // Each pattern/path segment pair is visited once, even with repeated **.\n    let next = new Uint8Array(parts.length + 1)\n    next[parts.length] = 1\n    for (let index = segments.length - 1; index >= 0; index--) {\n      const segment = segments[index]\n      const current = new Uint8Array(parts.length + 1)\n      for (let part = parts.length - 1; part >= 0; part--) {\n        current[part] = segment === undefined\n          // A trailing ** accepts every remaining code unit. It still needs\n          // the separator preceding it: src/** does not match bare src.\n          ? Number(\n            index === segments.length - 1 || next[part] === 1 ||\n              (parts[part] !== \"\" && current[part + 1] === 1)\n          )\n          : Number(next[part + 1] === 1 && segment(parts[part]!))\n      }\n      next = current\n    }\n    return next[0] === 1\n  }\n  patternMatchers.set(key, matcher)\n  return matcher\n}\n\n/** Tests one workspace-relative path against one Bazel-style pattern.\n * @category predicates\n * @since 0.1.0\n * @slop\n */\nexport const matchesPattern = (pattern: string, path: string): boolean => patternMatcher(pattern)(path)\n\n/** Tests one file path against a glob, including exclusions.\n * @category predicates\n * @since 0.1.0\n * @slop\n */\nexport const matchesGlob = (glob: Glob, path: string): boolean =>\n  glob.include.some((pattern) => matchesPattern(pattern, path)) &&\n  !(glob.exclude ?? []).some((pattern) => matchesPattern(pattern, path))\n\nconst beneath = (tree: string, path: string): boolean => {\n  const root = folded(tree)\n  const inside = folded(path)\n  return inside === root || inside.startsWith(`${root}/`)\n}\n\n/** {@link matchesGlob} over {@link folded} spellings of the glob and the path. */\nconst matchesGlobFolded = (glob: Glob, path: string): boolean => {\n  const inside = folded(path)\n  return glob.include.some((pattern) => matchesPattern(folded(pattern), inside)) &&\n    !(glob.exclude ?? []).some((pattern) => matchesPattern(folded(pattern), inside))\n}\n\n/**\n * Conservative static overlap. `true` may over-serialize; `false` proves that\n * no path can belong to both declarations.\n *\n * A plain string is a literal path, even when it contains `*` or `**`, as it\n * is at execution (sandbox admission, capture, removal, and replay); wildcard\n * matching belongs to a Glob.\n *\n * Exact paths and tree roots compare in their\n * {@link folded} form, so separator aliases, canonically equivalent Unicode\n * spellings, and spellings that differ only in letter case overlap. A Glob\n * against an exact path matches both its `include` and `exclude` patterns in\n * folded form. {@link matchesGlob} itself stays case-sensitive and tests the path bytes it\n * is handed; its property suite pins a backslash inside a path segment as\n * literal text, so canonicalizing a measured path before matching is its\n * caller's decision, not this module's.\n *\n * @category predicates\n * @since 0.1.0\n * @slop\n */\nexport const overlaps = (left: Entry, right: Entry): boolean => {\n  if (typeof left === \"string\" && typeof right === \"string\") return folded(left) === folded(right)\n  if (typeof left === \"string\" && isGlob(right)) return matchesGlobFolded(right, left)\n  if (isGlob(left) && typeof right === \"string\") return matchesGlobFolded(left, right)\n  if (isGlob(left) && isGlob(right)) return true\n  if (isTreeArtifact(left) && typeof right === \"string\") return beneath(left.path, right)\n  if (typeof left === \"string\" && isTreeArtifact(right)) return beneath(right.path, left)\n  if (isTreeArtifact(left) && isTreeArtifact(right)) {\n    return beneath(left.path, right.path) || beneath(right.path, left.path)\n  }\n  if (isTreeArtifact(left) && isGlob(right)) return true\n  /* v8 ignore else -- the closed Entry union leaves only Glob/TreeArtifact here */\n  if (isGlob(left) && isTreeArtifact(right)) return overlaps(right, left)\n  /* v8 ignore next -- Entry's closed union makes every pair return above */\n  return true\n}\n"],
+  "mappings": "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",
+  "names": ["matched"]
+}

package/dist/cjs/GraphBuildError.d.ts

@@ -0,0 +1,122 @@
+/**
+ * The refusals a plan-time build raises instead of producing a wrong plan.
+ *
+ * Every one of these fails LOUDLY at build time: a planned value that was computed on must not
+ * bake `NaN` into a plan, an arm that returned something other than a node must
+ * not silently vanish from the topology, and a recursive `.call()` must direct
+ * the author to `.to()` or `.child()` rather than expanding forever. Each
+ * failure therefore names the site (`node` plus the recorded property `path`)
+ * and states the fix in `message`, because the author reading it is mid-body
+ * and needs the correction, not a classification.
+ *
+ * The codes are a closed schema literal so a caller can switch on them, and so
+ * a new refusal is a deliberate addition rather than a new free-form string.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * The stable code of a build refusal.
+ *
+ * `planned_value_computed` is a body computing on a step result;
+ * `invalid_all_member` is a non-node handed to {@link module:Node.all};
+ * `invalid_join` is a race, any, or quorum with a non-node member, no members,
+ * or a quorum count its members cannot reach;
+ * `invalid_continuation` is a branch arm or continuation that did not return a
+ * node; `recursion_requires_boundary` is a flow calling itself inline, which
+ * has to become a trampoline handoff or an explicit child boundary;
+ * `placement_requires_boundary` is an inline call whose callee declares a
+ * placement the enclosing flow cannot satisfy, which has to become that same
+ * explicit child boundary; `cyclic_payload` is a payload that contains itself,
+ * which no plan could serialize or hash; `payload_too_deep` is a payload
+ * nested past the build bound, which has to be flattened into shallower data;
+ * `graph_too_deep` is authored topology nested past the build bound, which
+ * has to be split with `.child()` boundaries or trampoline handoffs;
+ * `duplicate_node` is two structural graph addresses resolving to one durable
+ * node id;
+ * `invalid_priority` is a scheduling priority that is not a safe integer,
+ * which no ordering could compare; `invalid_payload` is a payload member that
+ * cannot be captured as inert JSON without executing author code or losing
+ * identity; `unstable_callback` is a function with process-local identity in a
+ * graph that requires stable callbacks. Declare its complete inert captures
+ * with `Node.capture`, including semantic implementation versions. The two
+ * depth refusals exist because graph building walks with an explicit stack
+ * and refuses at a bound, rather than recursing until the native stack
+ * overflows without a typed error.
+ *
+ * The four effect-authority refusals are raised when a declaration claims more
+ * than the declaration enclosing it granted:
+ * `effect_outside_envelope` is a read or write path the envelope does not
+ * cover, and it names those paths in `path`; `effect_mode_widening` is an
+ * `expected` declaration inside a `hermetic` envelope; `effect_tier_widening`
+ * is a tier less reversible than the envelope's; and
+ * `capability_outside_grant` is a called flow or action requiring a capability
+ * the caller does not hold, which names the dropped capabilities in `path`. The
+ * first three are fatal by {@link isFatalDiagnostic}; the fourth is advisory,
+ * because dropping a capability narrows authority rather than widening it.
+ *
+ * The last six are raised by `@smthrs/core`'s graph builder, which uses this
+ * one error rather than a second class of its own. `write_conflict` is two work
+ * nodes overlapping under `onConflict: "fail"`, and `node` names the first of
+ * the pair while `Graph.conflicts` carries both; `missing_key_material` is a
+ * node that reached key compilation without any; `dependency_cycle` is a
+ * dependency set that cannot be ordered, and `node` names a node in the cycle;
+ * `plan_too_large` is a node, edge, conflict, or effect-path limit crossed, and
+ * `node` names the node whose admission crossed it; `payload_too_large` is a
+ * plan value with more members than the bound, and `path` names the offending
+ * value path; `invalid_node` is a malformed node AST. All six are fatal.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+export declare const GraphBuildErrorCode: Schema.Literals<readonly ["planned_value_computed", "invalid_all_member", "invalid_join", "invalid_continuation", "recursion_requires_boundary", "placement_requires_boundary", "cyclic_payload", "payload_too_deep", "graph_too_deep", "duplicate_node", "invalid_priority", "invalid_payload", "unstable_callback", "effect_outside_envelope", "effect_mode_widening", "effect_tier_widening", "capability_outside_grant", "write_conflict", "missing_key_material", "dependency_cycle", "plan_too_large", "payload_too_large", "invalid_node"]>;
+/**
+ * The value form of {@link GraphBuildErrorCode}.
+ *
+ * @since 0.1.0
+ * @category models
+ * @slop
+ */
+export type GraphBuildErrorCode = typeof GraphBuildErrorCode.Type;
+declare const GraphBuildError_base: Schema.Class<GraphBuildError, Schema.TaggedStruct<"@smthrs/plan/GraphBuildError", {
+    readonly code: Schema.Literals<readonly ["planned_value_computed", "invalid_all_member", "invalid_join", "invalid_continuation", "recursion_requires_boundary", "placement_requires_boundary", "cyclic_payload", "payload_too_deep", "graph_too_deep", "duplicate_node", "invalid_priority", "invalid_payload", "unstable_callback", "effect_outside_envelope", "effect_mode_widening", "effect_tier_widening", "capability_outside_grant", "write_conflict", "missing_key_material", "dependency_cycle", "plan_too_large", "payload_too_large", "invalid_node"]>;
+    readonly node: Schema.String;
+    readonly path: Schema.$Array<Schema.String>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A build the planner refuses, naming the site and the fix.
+ *
+ * `node` is the node reference the failure belongs to — a planned value's
+ * origin node, an `all` member name, a branch arm, or the node whose admission
+ * crossed a bound. `path` is the property path recorded on a planned value
+ * before it was misused, the effect paths an over-claiming declaration named,
+ * the capabilities a call lost, or the value path of an oversized payload; it
+ * is empty for every other code.
+ *
+ * This is the ONE build refusal. `@smthrs/core`'s graph builder raised a second
+ * `GraphBuildError` of its own, with `paths`, `nodeId` and `nodes` in place of
+ * these fields, and the two code sets diverged instead of merging. A conflict's
+ * second node is read from `Graph.conflicts`, which carries the pair.
+ *
+ * @since 0.1.0
+ * @category errors
+ * @slop
+ */
+export declare class GraphBuildError extends GraphBuildError_base {
+}
+/**
+ * Whether a recorded refusal blocks the drafts a plan is compiled from.
+ *
+ * A fatal refusal means the graph describes something no plan could execute as
+ * written, so the drafts are withheld. An advisory one reports a narrowing the
+ * author should see while the graph still compiles.
+ *
+ * @since 0.1.0
+ * @category predicates
+ * @slop
+ */
+export declare const isFatalDiagnostic: (diagnostic: GraphBuildError) => boolean;
+export {};
+//# sourceMappingURL=GraphBuildError.d.ts.map

package/dist/cjs/GraphBuildError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphBuildError.d.ts","sourceRoot":"","sources":["../../src/GraphBuildError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,mBAAmB,ohBAwB9B,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;;;;;;;AAEjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,eAAgB,SAAQ,oBAKnC;CAAG;AAaL;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAAI,YAAY,eAAe,KAAG,OAA8C,CAAA"}

package/dist/cjs/GraphBuildError.js

@@ -0,0 +1,71 @@
+"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 GraphBuildError_exports = {};
+__export(GraphBuildError_exports, {
+  GraphBuildError: () => GraphBuildError,
+  GraphBuildErrorCode: () => GraphBuildErrorCode,
+  isFatalDiagnostic: () => isFatalDiagnostic
+});
+module.exports = __toCommonJS(GraphBuildError_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+const GraphBuildErrorCode = Schema.Literals([
+  "planned_value_computed",
+  "invalid_all_member",
+  "invalid_join",
+  "invalid_continuation",
+  "recursion_requires_boundary",
+  "placement_requires_boundary",
+  "cyclic_payload",
+  "payload_too_deep",
+  "graph_too_deep",
+  "duplicate_node",
+  "invalid_priority",
+  "invalid_payload",
+  "unstable_callback",
+  "effect_outside_envelope",
+  "effect_mode_widening",
+  "effect_tier_widening",
+  "capability_outside_grant",
+  "write_conflict",
+  "missing_key_material",
+  "dependency_cycle",
+  "plan_too_large",
+  "payload_too_large",
+  "invalid_node"
+]);
+class GraphBuildError extends Schema.TaggedError()("@smthrs/plan/GraphBuildError", {
+  code: GraphBuildErrorCode,
+  node: Schema.String,
+  path: Schema.Array(Schema.String),
+  message: Schema.String
+}) {
+}
+const advisoryCodes = /* @__PURE__ */ new Set(["capability_outside_grant"]);
+const isFatalDiagnostic = (diagnostic) => !advisoryCodes.has(diagnostic.code);
+//# sourceMappingURL=GraphBuildError.js.map

package/dist/cjs/GraphBuildError.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/GraphBuildError.ts"],
+  "sourcesContent": ["/**\n * The refusals a plan-time build raises instead of producing a wrong plan.\n *\n * Every one of these fails LOUDLY at build time: a planned value that was computed on must not\n * bake `NaN` into a plan, an arm that returned something other than a node must\n * not silently vanish from the topology, and a recursive `.call()` must direct\n * the author to `.to()` or `.child()` rather than expanding forever. Each\n * failure therefore names the site (`node` plus the recorded property `path`)\n * and states the fix in `message`, because the author reading it is mid-body\n * and needs the correction, not a classification.\n *\n * The codes are a closed schema literal so a caller can switch on them, and so\n * a new refusal is a deliberate addition rather than a new free-form string.\n *\n * @since 0.1.0\n */\n\nimport * as Schema from \"effect/Schema\"\n\n/**\n * The stable code of a build refusal.\n *\n * `planned_value_computed` is a body computing on a step result;\n * `invalid_all_member` is a non-node handed to {@link module:Node.all};\n * `invalid_join` is a race, any, or quorum with a non-node member, no members,\n * or a quorum count its members cannot reach;\n * `invalid_continuation` is a branch arm or continuation that did not return a\n * node; `recursion_requires_boundary` is a flow calling itself inline, which\n * has to become a trampoline handoff or an explicit child boundary;\n * `placement_requires_boundary` is an inline call whose callee declares a\n * placement the enclosing flow cannot satisfy, which has to become that same\n * explicit child boundary; `cyclic_payload` is a payload that contains itself,\n * which no plan could serialize or hash; `payload_too_deep` is a payload\n * nested past the build bound, which has to be flattened into shallower data;\n * `graph_too_deep` is authored topology nested past the build bound, which\n * has to be split with `.child()` boundaries or trampoline handoffs;\n * `duplicate_node` is two structural graph addresses resolving to one durable\n * node id;\n * `invalid_priority` is a scheduling priority that is not a safe integer,\n * which no ordering could compare; `invalid_payload` is a payload member that\n * cannot be captured as inert JSON without executing author code or losing\n * identity; `unstable_callback` is a function with process-local identity in a\n * graph that requires stable callbacks. Declare its complete inert captures\n * with `Node.capture`, including semantic implementation versions. The two\n * depth refusals exist because graph building walks with an explicit stack\n * and refuses at a bound, rather than recursing until the native stack\n * overflows without a typed error.\n *\n * The four effect-authority refusals are raised when a declaration claims more\n * than the declaration enclosing it granted:\n * `effect_outside_envelope` is a read or write path the envelope does not\n * cover, and it names those paths in `path`; `effect_mode_widening` is an\n * `expected` declaration inside a `hermetic` envelope; `effect_tier_widening`\n * is a tier less reversible than the envelope's; and\n * `capability_outside_grant` is a called flow or action requiring a capability\n * the caller does not hold, which names the dropped capabilities in `path`. The\n * first three are fatal by {@link isFatalDiagnostic}; the fourth is advisory,\n * because dropping a capability narrows authority rather than widening it.\n *\n * The last six are raised by `@smthrs/core`'s graph builder, which uses this\n * one error rather than a second class of its own. `write_conflict` is two work\n * nodes overlapping under `onConflict: \"fail\"`, and `node` names the first of\n * the pair while `Graph.conflicts` carries both; `missing_key_material` is a\n * node that reached key compilation without any; `dependency_cycle` is a\n * dependency set that cannot be ordered, and `node` names a node in the cycle;\n * `plan_too_large` is a node, edge, conflict, or effect-path limit crossed, and\n * `node` names the node whose admission crossed it; `payload_too_large` is a\n * plan value with more members than the bound, and `path` names the offending\n * value path; `invalid_node` is a malformed node AST. All six are fatal.\n *\n * @since 0.1.0\n * @category schemas\n * @slop\n */\nexport const GraphBuildErrorCode = Schema.Literals([\n  \"planned_value_computed\",\n  \"invalid_all_member\",\n  \"invalid_join\",\n  \"invalid_continuation\",\n  \"recursion_requires_boundary\",\n  \"placement_requires_boundary\",\n  \"cyclic_payload\",\n  \"payload_too_deep\",\n  \"graph_too_deep\",\n  \"duplicate_node\",\n  \"invalid_priority\",\n  \"invalid_payload\",\n  \"unstable_callback\",\n  \"effect_outside_envelope\",\n  \"effect_mode_widening\",\n  \"effect_tier_widening\",\n  \"capability_outside_grant\",\n  \"write_conflict\",\n  \"missing_key_material\",\n  \"dependency_cycle\",\n  \"plan_too_large\",\n  \"payload_too_large\",\n  \"invalid_node\"\n])\n\n/**\n * The value form of {@link GraphBuildErrorCode}.\n *\n * @since 0.1.0\n * @category models\n * @slop\n */\nexport type GraphBuildErrorCode = typeof GraphBuildErrorCode.Type\n\n/**\n * A build the planner refuses, naming the site and the fix.\n *\n * `node` is the node reference the failure belongs to \u2014 a planned value's\n * origin node, an `all` member name, a branch arm, or the node whose admission\n * crossed a bound. `path` is the property path recorded on a planned value\n * before it was misused, the effect paths an over-claiming declaration named,\n * the capabilities a call lost, or the value path of an oversized payload; it\n * is empty for every other code.\n *\n * This is the ONE build refusal. `@smthrs/core`'s graph builder raised a second\n * `GraphBuildError` of its own, with `paths`, `nodeId` and `nodes` in place of\n * these fields, and the two code sets diverged instead of merging. A conflict's\n * second node is read from `Graph.conflicts`, which carries the pair.\n *\n * @since 0.1.0\n * @category errors\n * @slop\n */\nexport class GraphBuildError extends Schema.TaggedError<GraphBuildError>()(\"@smthrs/plan/GraphBuildError\", {\n  code: GraphBuildErrorCode,\n  node: Schema.String,\n  path: Schema.Array(Schema.String),\n  message: Schema.String\n}) {}\n\n/**\n * The one advisory code. Everything else a build records blocks the drafts.\n *\n * A capability the caller does not grant is DROPPED, not granted: the callee\n * runs with less authority than it asked for, which is the safe direction. The\n * author still needs to know, because a flow that silently loses a capability\n * fails later at the action that needed it, so the build records the refusal\n * and lets the graph compile.\n */\nconst advisoryCodes: ReadonlySet<GraphBuildErrorCode> = new Set<GraphBuildErrorCode>([\"capability_outside_grant\"])\n\n/**\n * Whether a recorded refusal blocks the drafts a plan is compiled from.\n *\n * A fatal refusal means the graph describes something no plan could execute as\n * written, so the drafts are withheld. An advisory one reports a narrowing the\n * author should see while the graph still compiles.\n *\n * @since 0.1.0\n * @category predicates\n * @slop\n */\nexport const isFatalDiagnostic = (diagnostic: GraphBuildError): boolean => !advisoryCodes.has(diagnostic.code)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,aAAwB;AAyDjB,MAAM,sBAAsB,OAAO,SAAS;AAAA,EACjD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AA8BM,MAAM,wBAAwB,OAAO,YAA6B,EAAE,gCAAgC;AAAA,EACzG,MAAM;AAAA,EACN,MAAM,OAAO;AAAA,EACb,MAAM,OAAO,MAAM,OAAO,MAAM;AAAA,EAChC,SAAS,OAAO;AAClB,CAAC,EAAE;AAAC;AAWJ,MAAM,gBAAkD,oBAAI,IAAyB,CAAC,0BAA0B,CAAC;AAa1G,MAAM,oBAAoB,CAAC,eAAyC,CAAC,cAAc,IAAI,WAAW,IAAI;",
+  "names": []
+}

package/dist/cjs/KeyMaterial.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The key-material contract: what a planner hands the step-key compiler.
+ *
+ * Revived from the deleted `packages/smithers/flows/keys/src/KeyMaterial.ts`.
+ * It does NOT return to `@smthrs/keys`: that package owns generic derivation
+ * and stored-key validation, while material is a *plan-shaped* concept. It
+ * lives here, above `@smthrs/keys`, so the key package stays a leaf.
+ *
+ * Governing contract: the step-key rules at
+ * https://smithers.sh/docs/concepts/content-addressing. Material is computed with no I/O,
+ * and two hardening rules shape it: the nominal, never shape-sniffed
+ * `InputRef` and the hashed `version`.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * A reference to one declared input of a node: a value hashed inline, or the
+ * key of an upstream node whose result this node consumes.
+ *
+ * The three variants are tagged, and the tag is hashed, so `Pending{from}` and
+ * `Ref{from, path: []}` — which resolve to the same dependency digest — can
+ * never collide.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+export declare const InputRef: Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+    readonly value: Schema.Unknown;
+}>, Schema.TaggedStruct<"Ref", {
+    readonly from: Schema.NonEmptyString;
+    readonly path: Schema.$Array<Schema.String>;
+}>, Schema.TaggedStruct<"Pending", {
+    readonly from: Schema.NonEmptyString;
+}>]>;
+/**
+ * A reference to one declared input of a node.
+ *
+ * @since 0.1.0
+ * @category models
+ * @slop
+ */
+export type InputRef = typeof InputRef.Type;
+/**
+ * The material version. Folded into every hashed body so a bump re-keys every
+ * node derived from it — the original's second collision fix, kept.
+ *
+ * @since 0.1.0
+ * @category constants
+ * @slop
+ */
+export declare const version = "flows/key-material/v2";
+/**
+ * Everything that can change a node's result, handed to the digest.
+ *
+ * `effects` and `placement` are opaque: canonically serialized, never
+ * interpreted, which is what keeps the compiler independent of whatever the
+ * flow builder decides an effect declaration looks like.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+export declare const KeyMaterial: Schema.Struct<{
+    readonly version: Schema.Literal<"flows/key-material/v2">;
+    readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+    readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+    readonly body: Schema.Unknown;
+    readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+        readonly value: Schema.Unknown;
+    }>, Schema.TaggedStruct<"Ref", {
+        readonly from: Schema.NonEmptyString;
+        readonly path: Schema.$Array<Schema.String>;
+    }>, Schema.TaggedStruct<"Pending", {
+        readonly from: Schema.NonEmptyString;
+    }>]>>;
+    readonly layers: Schema.$Array<Schema.String>;
+    readonly capabilities: Schema.$Array<Schema.String>;
+    readonly effects: Schema.optional<Schema.Unknown>;
+    readonly placement: Schema.optional<Schema.Unknown>;
+}>;
+/**
+ * Everything that can change a node's result, handed to the digest.
+ *
+ * @since 0.1.0
+ * @category models
+ * @slop
+ */
+export type KeyMaterial = typeof KeyMaterial.Type;
+/**
+ * The graph-local dependencies a material names, in declaration order and
+ * without duplicates. The compiler resolves exactly these before hashing, and
+ * {@link module:Plan} uses them as the edge set — one derivation, so an edge
+ * and a hashed reference can never disagree.
+ *
+ * @since 0.1.0
+ * @category accessors
+ * @slop
+ */
+export declare const dependencies: (material: KeyMaterial) => ReadonlyArray<string>;
+//# sourceMappingURL=KeyMaterial.d.ts.map

package/dist/cjs/KeyMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyMaterial.d.ts","sourceRoot":"","sources":["../../src/KeyMaterial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ;;;;;;;IAInB,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,0BAA0B,CAAA;AAE9C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;EAWtB,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU,WAAW,KAAG,aAAa,CAAC,MAAM,CAMxE,CAAA"}

package/dist/cjs/KeyMaterial.js

@@ -0,0 +1,64 @@
+"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 KeyMaterial_exports = {};
+__export(KeyMaterial_exports, {
+  InputRef: () => InputRef,
+  KeyMaterial: () => KeyMaterial,
+  dependencies: () => dependencies,
+  version: () => version
+});
+module.exports = __toCommonJS(KeyMaterial_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Effects = __toESM(require("./Effects.js"), 1);
+const InputRef = Schema.Union([
+  Schema.TaggedStruct("Literal", { value: Schema.Unknown }),
+  Schema.TaggedStruct("Ref", { from: Schema.NonEmptyString, path: Schema.Array(Schema.String) }),
+  Schema.TaggedStruct("Pending", { from: Schema.NonEmptyString })
+]);
+const version = "flows/key-material/v2";
+const KeyMaterial = Schema.Struct({
+  version: Schema.Literal(version),
+  kind: Effects.Tier,
+  // Absence claims determinism; only the explicit declaration changes identity.
+  nondeterministic: Schema.optional(Schema.Literal(true)),
+  body: Schema.Unknown,
+  inputs: Schema.Array(InputRef),
+  layers: Schema.Array(Schema.String),
+  capabilities: Schema.Array(Schema.String),
+  effects: Schema.optional(Schema.Unknown),
+  placement: Schema.optional(Schema.Unknown)
+});
+const dependencies = (material) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const input of material.inputs) {
+    if (input._tag !== "Literal") seen.add(input.from);
+  }
+  return [...seen];
+};
+//# sourceMappingURL=KeyMaterial.js.map

package/dist/cjs/KeyMaterial.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/KeyMaterial.ts"],
+  "sourcesContent": ["/**\n * The key-material contract: what a planner hands the step-key compiler.\n *\n * Revived from the deleted `packages/smithers/flows/keys/src/KeyMaterial.ts`.\n * It does NOT return to `@smthrs/keys`: that package owns generic derivation\n * and stored-key validation, while material is a *plan-shaped* concept. It\n * lives here, above `@smthrs/keys`, so the key package stays a leaf.\n *\n * Governing contract: the step-key rules at\n * https://smithers.sh/docs/concepts/content-addressing. Material is computed with no I/O,\n * and two hardening rules shape it: the nominal, never shape-sniffed\n * `InputRef` and the hashed `version`.\n *\n * @since 0.1.0\n */\n\nimport * as Schema from \"effect/Schema\"\nimport * as Effects from \"./Effects.ts\"\n\n/**\n * A reference to one declared input of a node: a value hashed inline, or the\n * key of an upstream node whose result this node consumes.\n *\n * The three variants are tagged, and the tag is hashed, so `Pending{from}` and\n * `Ref{from, path: []}` \u2014 which resolve to the same dependency digest \u2014 can\n * never collide.\n *\n * @since 0.1.0\n * @category schemas\n * @slop\n */\nexport const InputRef = Schema.Union([\n  Schema.TaggedStruct(\"Literal\", { value: Schema.Unknown }),\n  Schema.TaggedStruct(\"Ref\", { from: Schema.NonEmptyString, path: Schema.Array(Schema.String) }),\n  Schema.TaggedStruct(\"Pending\", { from: Schema.NonEmptyString })\n])\n\n/**\n * A reference to one declared input of a node.\n *\n * @since 0.1.0\n * @category models\n * @slop\n */\nexport type InputRef = typeof InputRef.Type\n\n/**\n * The material version. Folded into every hashed body so a bump re-keys every\n * node derived from it \u2014 the original's second collision fix, kept.\n *\n * @since 0.1.0\n * @category constants\n * @slop\n */\nexport const version = \"flows/key-material/v2\"\n\n/**\n * Everything that can change a node's result, handed to the digest.\n *\n * `effects` and `placement` are opaque: canonically serialized, never\n * interpreted, which is what keeps the compiler independent of whatever the\n * flow builder decides an effect declaration looks like.\n *\n * @since 0.1.0\n * @category schemas\n * @slop\n */\nexport const KeyMaterial = Schema.Struct({\n  version: Schema.Literal(version),\n  kind: Effects.Tier,\n  // Absence claims determinism; only the explicit declaration changes identity.\n  nondeterministic: Schema.optional(Schema.Literal(true)),\n  body: Schema.Unknown,\n  inputs: Schema.Array(InputRef),\n  layers: Schema.Array(Schema.String),\n  capabilities: Schema.Array(Schema.String),\n  effects: Schema.optional(Schema.Unknown),\n  placement: Schema.optional(Schema.Unknown)\n})\n\n/**\n * Everything that can change a node's result, handed to the digest.\n *\n * @since 0.1.0\n * @category models\n * @slop\n */\nexport type KeyMaterial = typeof KeyMaterial.Type\n\n/**\n * The graph-local dependencies a material names, in declaration order and\n * without duplicates. The compiler resolves exactly these before hashing, and\n * {@link module:Plan} uses them as the edge set \u2014 one derivation, so an edge\n * and a hashed reference can never disagree.\n *\n * @since 0.1.0\n * @category accessors\n * @slop\n */\nexport const dependencies = (material: KeyMaterial): ReadonlyArray<string> => {\n  const seen = new Set<string>()\n  for (const input of material.inputs) {\n    if (input._tag !== \"Literal\") seen.add(input.from)\n  }\n  return [...seen]\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,aAAwB;AACxB,cAAyB;AAclB,MAAM,WAAW,OAAO,MAAM;AAAA,EACnC,OAAO,aAAa,WAAW,EAAE,OAAO,OAAO,QAAQ,CAAC;AAAA,EACxD,OAAO,aAAa,OAAO,EAAE,MAAM,OAAO,gBAAgB,MAAM,OAAO,MAAM,OAAO,MAAM,EAAE,CAAC;AAAA,EAC7F,OAAO,aAAa,WAAW,EAAE,MAAM,OAAO,eAAe,CAAC;AAChE,CAAC;AAmBM,MAAM,UAAU;AAahB,MAAM,cAAc,OAAO,OAAO;AAAA,EACvC,SAAS,OAAO,QAAQ,OAAO;AAAA,EAC/B,MAAM,QAAQ;AAAA;AAAA,EAEd,kBAAkB,OAAO,SAAS,OAAO,QAAQ,IAAI,CAAC;AAAA,EACtD,MAAM,OAAO;AAAA,EACb,QAAQ,OAAO,MAAM,QAAQ;AAAA,EAC7B,QAAQ,OAAO,MAAM,OAAO,MAAM;AAAA,EAClC,cAAc,OAAO,MAAM,OAAO,MAAM;AAAA,EACxC,SAAS,OAAO,SAAS,OAAO,OAAO;AAAA,EACvC,WAAW,OAAO,SAAS,OAAO,OAAO;AAC3C,CAAC;AAqBM,MAAM,eAAe,CAAC,aAAiD;AAC5E,QAAM,OAAO,oBAAI,IAAY;AAC7B,aAAW,SAAS,SAAS,QAAQ;AACnC,QAAI,MAAM,SAAS,UAAW,MAAK,IAAI,MAAM,IAAI;AAAA,EACnD;AACA,SAAO,CAAC,GAAG,IAAI;AACjB;",
+  "names": []
+}