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

package/dist/esm/FileSet.js

@@ -0,0 +1,398 @@
+/**
+ * Static filesystem declaration vocabulary shared by planning and execution.
+ *
+ * Declared paths use `/` as their canonical separator and normalize Unicode
+ * to NFC. Workspace-relative paths reject C0 controls (U+0000 through U+001F)
+ * and DEL (U+007F), which name nothing a supported filesystem can open. C1
+ * controls (U+0080 through U+009F) remain accepted because those bytes are
+ * legal in a POSIX file name.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * How strictly a declared file set is enforced at the boundary.
+ *
+ * `hard` rejects undeclared access. `expected` records access for validation
+ * after execution without requiring the sandbox to reject it immediately.
+ *
+ * This is the ONE spelling of the pair. `Plan.NodeEffects.boundaryMode` is this
+ * schema and so is `@smthrs/flow`'s `Action.BoundaryMode`; the literal used to
+ * be written out in all three places.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export const BoundaryMode = Schema.Literals(["hard", "expected"]);
+/**
+ * The canonical spelling of a declared path or pattern: every separator is
+ * `/`, and Unicode is normalized to NFC.
+ *
+ * {@link workspaceRelative} accepts a backslash as a separator, so
+ * `dist\same.js` and `dist/same.js` are two spellings of ONE workspace path.
+ * Every exact-path comparison in this module goes through this form, because
+ * comparing the raw spellings would let the separator alias defeat overlap
+ * detection exactly as `.` segments and empty segments would.
+ *
+ * @category accessors
+ * @since 0.1.0
+ */
+export const canonical = (path) => path.replaceAll("\\", "/").normalize("NFC");
+/**
+ * The {@link canonical} spelling with letter case folded away.
+ *
+ * A case-insensitive filesystem (default macOS APFS, Windows NTFS) opens
+ * `src/A.ts` and `src/a.ts` as one file, so static overlap compares this form:
+ * two declarations that differ only in case must serialize. Folding goes
+ * through upper case because that mapping is context-free, so it folds each
+ * character alone and commutes with splitting a path into segments.
+ *
+ * @category accessors
+ * @since 1.0.0-rc.0
+ */
+export const folded = (path) => canonical(path).toUpperCase().normalize("NFC");
+/**
+ * A non-empty workspace-relative path or pattern.
+ *
+ * Decoding fails with a `SchemaError` when {@link workspaceRelative} refuses
+ * the string. A bare `Pattern` in a declaration names one literal path; only a
+ * {@link Glob} gives `*` and `**` wildcard meaning.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const Pattern = Schema.NonEmptyString.check(Schema.makeFilter((pattern) => workspaceRelative(pattern) || "file patterns must be workspace-relative and cannot traverse upward", { title: "workspaceRelativePattern" }));
+/**
+ * Whether a declared path or pattern stays inside the workspace and names it
+ * one way only. Refuses absolute paths (POSIX and drive-letter), upward
+ * traversal, and the aliasing forms — `.` segments, empty segments — that
+ * would let two spellings of one file defeat exact-string overlap detection.
+ *
+ * C0 controls and DEL are refused as well.
+ *
+ * @category predicates
+ * @since 0.1.0
+ */
+export const workspaceRelative = (pattern) => {
+    for (let index = 0; index < pattern.length; index++) {
+        const code = pattern.charCodeAt(index);
+        if (code <= 0x1f || code === 0x7f)
+            return false;
+    }
+    if (pattern.startsWith("/"))
+        return false;
+    const segments = canonical(pattern).split("/");
+    // `C:foo` is drive-relative on Windows, so any drive-letter prefix escapes.
+    if (/^[A-Za-z]:/.test(segments[0]) || segments[0].endsWith(":"))
+        return false;
+    return segments.every((segment) => segment !== ".." && segment !== "." && segment !== "");
+};
+/**
+ * A Bazel-style file glob: the paths matching any `include` pattern and no
+ * `exclude` pattern.
+ *
+ * In a pattern, `*` matches within one path segment and a `**` segment
+ * matches zero or more whole segments. A trailing `**` needs its separator,
+ * so `src/**` does not match `src` itself.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const Glob = Schema.TaggedStruct("Glob", {
+    include: Schema.NonEmptyArray(Pattern),
+    exclude: Schema.optional(Schema.Array(Pattern))
+});
+/**
+ * A directory output captured and replayed as one tree artifact.
+ *
+ * It covers `path` and every path beneath it, compared in {@link folded}
+ * form.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const TreeArtifact = Schema.TaggedStruct("TreeArtifact", {
+    path: Pattern
+});
+/**
+ * One leaf declaration: a literal path, a {@link Glob}, or a
+ * {@link TreeArtifact}. Write sets and filegroups hold entries.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const Entry = Schema.Union([Pattern, Glob, TreeArtifact]);
+/**
+ * One leaf declaration valid in a read set: a literal path or a {@link Glob}.
+ * A read set cannot name a {@link TreeArtifact}, which is an output form.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const ReadEntry = Schema.Union([Pattern, Glob]);
+/**
+ * A named, reusable list of {@link Entry} declarations.
+ *
+ * {@link expand} replaces a filegroup with its entries in place before any
+ * overlap check or measurement, so the name never reaches the boundary.
+ * Filegroups do not nest.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const Filegroup = Schema.TaggedStruct("Filegroup", {
+    name: Schema.NonEmptyString,
+    entries: Schema.Array(Entry)
+});
+/**
+ * A {@link Filegroup} restricted to {@link ReadEntry} declarations, for use
+ * in a read set. It shares the `"Filegroup"` tag.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const ReadFilegroup = Schema.TaggedStruct("Filegroup", {
+    name: Schema.NonEmptyString,
+    entries: Schema.Array(ReadEntry)
+});
+/**
+ * Any declaration accepted in a write set: an {@link Entry} or a
+ * {@link Filegroup}.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const Declaration = Schema.Union([Entry, Filegroup]);
+/**
+ * Any declaration accepted in a read set: a {@link ReadEntry} or a
+ * {@link ReadFilegroup}.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const ReadDeclaration = Schema.Union([ReadEntry, ReadFilegroup]);
+/**
+ * Creates a {@link Filegroup}. It does not validate `name` or `entries`;
+ * decode through {@link Filegroup} when the input is untrusted.
+ *
+ * @param name - The filegroup name.
+ * @param entries - The entries the filegroup expands to, in order.
+ * @returns The filegroup value.
+ * @category constructors
+ * @since 0.1.0
+ */
+export const makeFilegroup = (name, entries) => ({
+    _tag: "Filegroup",
+    name,
+    entries
+});
+/**
+ * Replaces each {@link Filegroup} with its entries, in place, and keeps every
+ * other declaration as it is. Order is preserved and duplicates are kept.
+ *
+ * @param declarations - Write-set declarations, possibly holding filegroups.
+ * @returns The flat list of entries.
+ * @category accessors
+ * @since 0.1.0
+ */
+export const expand = (declarations) => declarations.flatMap((declaration) => typeof declaration !== "string" && declaration._tag === "Filegroup" ? declaration.entries : [declaration]);
+/**
+ * {@link expand} for read sets: replaces each {@link ReadFilegroup} with its
+ * entries, in place, preserving order and duplicates.
+ *
+ * @param declarations - Read-set declarations, possibly holding filegroups.
+ * @returns The flat list of read entries.
+ * @category accessors
+ * @since 0.1.0
+ */
+export const expandReads = (declarations) => declarations.flatMap((declaration) => typeof declaration !== "string" && declaration._tag === "Filegroup" ? declaration.entries : [declaration]);
+/**
+ * Whether a value carries the `"Glob"` tag. It checks only the tag, not the
+ * patterns.
+ *
+ * @param value - Any value.
+ * @returns `true` for an object whose `_tag` is `"Glob"`.
+ * @category guards
+ * @since 0.1.0
+ */
+export const isGlob = (value) => typeof value === "object" && value !== null && "_tag" in value && value._tag === "Glob";
+/**
+ * Whether a value carries the `"TreeArtifact"` tag. It checks only the tag,
+ * not the path.
+ *
+ * @param value - Any value.
+ * @returns `true` for an object whose `_tag` is `"TreeArtifact"`.
+ * @category guards
+ * @since 0.1.0
+ */
+export const isTreeArtifact = (value) => typeof value === "object" && value !== null && "_tag" in value && value._tag === "TreeArtifact";
+/** KMP searches a literal without rescanning a long near-matching prefix. */
+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 matched = 0;
+        for (let index = start; index < end; index++) {
+            while (matched > 0 && path[index] !== literal[matched])
+                matched = fallback[matched - 1];
+            if (path[index] === literal[matched])
+                matched++;
+            if (matched === literal.length)
+                return index + 1;
+        }
+        return -1;
+    };
+};
+/** Anchored ends and disjoint literal searches make each segment match linear. */
+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 = new Map();
+/** Compile once per canonical spelling; recursive segments use no backtracking. */
+const patternMatcher = (pattern) => {
+    const key = canonical(pattern);
+    const cached = patternMatchers.get(key);
+    if (cached !== undefined)
+        return cached;
+    const segments = key.split("/").map((segment) => segment === "**" ? undefined : segmentMatcher(segment));
+    const matcher = (path) => {
+        const parts = path.split("/");
+        // Suffix membership: next[j] says the remaining pattern matches parts[j..].
+        // Each pattern/path segment pair is visited once, even with repeated **.
+        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 === undefined
+                    // A trailing ** accepts every remaining code unit. It still needs
+                    // the separator preceding it: src/** does not match bare src.
+                    ? 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;
+};
+/**
+ * Whether `path` matches `pattern` under {@link Glob} wildcard rules.
+ *
+ * The pattern is read in its {@link canonical} spelling; the path is matched
+ * as given, case-sensitively, with `/` as its only separator.
+ *
+ * @param pattern - A Bazel-style pattern such as `src/*.ts` or `docs/**`.
+ * @param path - A workspace-relative path.
+ * @returns `true` when the path matches.
+ * @category predicates
+ * @since 0.1.0
+ */
+export const matchesPattern = (pattern, path) => patternMatcher(pattern)(path);
+/**
+ * Whether `path` matches some `include` pattern of `glob` and no `exclude`
+ * pattern, each tested with {@link matchesPattern}. Case-sensitive.
+ *
+ * @param glob - The glob to test.
+ * @param path - A workspace-relative path.
+ * @returns `true` when the glob selects the path.
+ * @category predicates
+ * @since 0.1.0
+ */
+export 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}/`);
+};
+/**
+ * Whether a canonical path is inside a declaration, case-sensitively.
+ * Unlike {@link overlaps}, this predicate establishes replay authority.
+ *
+ * @category predicates
+ * @since 1.0.0-rc.0
+ */
+export const contains = (entry, path) => {
+    const inside = canonical(path);
+    if (typeof entry === "string")
+        return canonical(entry) === inside;
+    if (isGlob(entry))
+        return matchesGlob(entry, inside);
+    const root = canonical(entry.path);
+    return inside === root || inside.startsWith(`${root}/`);
+};
+/** Includes fold conservatively; exclusions cannot rule out all case aliases. */
+const mayMatchGlob = (glob, path) => glob.include.some((pattern) => matchesPattern(folded(pattern), folded(path)));
+/**
+ * Conservative static overlap. `true` may over-serialize; `false` proves that
+ * no path can belong to both declarations.
+ *
+ * A plain string is a literal path, even when it contains `*` or `**`, as it
+ * is at execution (sandbox admission, capture, removal, and replay); wildcard
+ * matching belongs to a Glob.
+ *
+ * Exact paths and tree roots compare in their
+ * {@link folded} form, so separator aliases, canonically equivalent Unicode
+ * spellings, and spellings that differ only in letter case overlap. A Glob
+ * against an exact path folds its includes and ignores exclusions: an excluded
+ * spelling may alias an included spelling on another filesystem. {@link matchesGlob} itself stays case-sensitive and tests the path bytes it
+ * is handed; its property suite pins a backslash inside a path segment as
+ * literal text, so canonicalizing a measured path before matching is its
+ * caller's decision, not this module's.
+ *
+ * @category predicates
+ * @since 0.1.0
+ */
+export const overlaps = (left, right) => {
+    if (typeof left === "string" && typeof right === "string")
+        return folded(left) === folded(right);
+    if (typeof left === "string" && isGlob(right))
+        return mayMatchGlob(right, left);
+    if (isGlob(left) && typeof right === "string")
+        return mayMatchGlob(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;
+    /* v8 ignore else -- the closed Entry union leaves only Glob/TreeArtifact here */
+    if (isGlob(left) && isTreeArtifact(right))
+        return overlaps(right, left);
+    /* v8 ignore next -- Entry's closed union makes every pair return above */
+    return true;
+};
+//# sourceMappingURL=FileSet.js.map

package/dist/esm/FileSet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSet.js","sourceRoot":"","sources":["../../src/FileSet.ts"],"names":[],"mappings":"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","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 */\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/**\n * A non-empty workspace-relative path or pattern.\n *\n * Decoding fails with a `SchemaError` when {@link workspaceRelative} refuses\n * the string. A bare `Pattern` in a declaration names one literal path; only a\n * {@link Glob} gives `*` and `**` wildcard meaning.\n *\n * @category schemas\n * @since 0.1.0\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 — `.` segments, empty segments — that\n * would let two spellings of one file defeat exact-string overlap detection.\n *\n * C0 controls and DEL are refused as well.\n *\n * @category predicates\n * @since 0.1.0\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/**\n * A Bazel-style file glob: the paths matching any `include` pattern and no\n * `exclude` pattern.\n *\n * In a pattern, `*` matches within one path segment and a `**` segment\n * matches zero or more whole segments. A trailing `**` needs its separator,\n * so `src/**` does not match `src` itself.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Glob = Schema.TaggedStruct(\"Glob\", {\n  include: Schema.NonEmptyArray(Pattern),\n  exclude: Schema.optional(Schema.Array(Pattern))\n})\n\n/**\n * The value form of {@link Glob}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Glob = typeof Glob.Type\n\n/**\n * A directory output captured and replayed as one tree artifact.\n *\n * It covers `path` and every path beneath it, compared in {@link folded}\n * form.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const TreeArtifact = Schema.TaggedStruct(\"TreeArtifact\", {\n  path: Pattern\n})\n\n/**\n * The value form of {@link TreeArtifact}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type TreeArtifact = typeof TreeArtifact.Type\n\n/**\n * One leaf declaration: a literal path, a {@link Glob}, or a\n * {@link TreeArtifact}. Write sets and filegroups hold entries.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Entry = Schema.Union([Pattern, Glob, TreeArtifact])\n\n/**\n * The value form of {@link Entry}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Entry = typeof Entry.Type\n\n/**\n * One leaf declaration valid in a read set: a literal path or a {@link Glob}.\n * A read set cannot name a {@link TreeArtifact}, which is an output form.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ReadEntry = Schema.Union([Pattern, Glob])\n\n/**\n * The value form of {@link ReadEntry}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type ReadEntry = typeof ReadEntry.Type\n\n/**\n * A named, reusable list of {@link Entry} declarations.\n *\n * {@link expand} replaces a filegroup with its entries in place before any\n * overlap check or measurement, so the name never reaches the boundary.\n * Filegroups do not nest.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Filegroup = Schema.TaggedStruct(\"Filegroup\", {\n  name: Schema.NonEmptyString,\n  entries: Schema.Array(Entry)\n})\n\n/**\n * The value form of {@link Filegroup}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Filegroup = typeof Filegroup.Type\n\n/**\n * A {@link Filegroup} restricted to {@link ReadEntry} declarations, for use\n * in a read set. It shares the `\"Filegroup\"` tag.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ReadFilegroup = Schema.TaggedStruct(\"Filegroup\", {\n  name: Schema.NonEmptyString,\n  entries: Schema.Array(ReadEntry)\n})\n\n/**\n * The value form of {@link ReadFilegroup}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type ReadFilegroup = typeof ReadFilegroup.Type\n\n/**\n * Any declaration accepted in a write set: an {@link Entry} or a\n * {@link Filegroup}.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Declaration = Schema.Union([Entry, Filegroup])\n\n/**\n * The value form of {@link Declaration}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Declaration = typeof Declaration.Type\n\n/**\n * Any declaration accepted in a read set: a {@link ReadEntry} or a\n * {@link ReadFilegroup}.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ReadDeclaration = Schema.Union([ReadEntry, ReadFilegroup])\n\n/**\n * The value form of {@link ReadDeclaration}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type ReadDeclaration = typeof ReadDeclaration.Type\n\n/**\n * Creates a {@link Filegroup}. It does not validate `name` or `entries`;\n * decode through {@link Filegroup} when the input is untrusted.\n *\n * @param name - The filegroup name.\n * @param entries - The entries the filegroup expands to, in order.\n * @returns The filegroup value.\n * @category constructors\n * @since 0.1.0\n */\nexport const makeFilegroup = (name: string, entries: ReadonlyArray<Entry>): Filegroup => ({\n  _tag: \"Filegroup\",\n  name,\n  entries\n})\n\n/**\n * Replaces each {@link Filegroup} with its entries, in place, and keeps every\n * other declaration as it is. Order is preserved and duplicates are kept.\n *\n * @param declarations - Write-set declarations, possibly holding filegroups.\n * @returns The flat list of entries.\n * @category accessors\n * @since 0.1.0\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/**\n * {@link expand} for read sets: replaces each {@link ReadFilegroup} with its\n * entries, in place, preserving order and duplicates.\n *\n * @param declarations - Read-set declarations, possibly holding filegroups.\n * @returns The flat list of read entries.\n * @category accessors\n * @since 0.1.0\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/**\n * Whether a value carries the `\"Glob\"` tag. It checks only the tag, not the\n * patterns.\n *\n * @param value - Any value.\n * @returns `true` for an object whose `_tag` is `\"Glob\"`.\n * @category guards\n * @since 0.1.0\n */\nexport const isGlob = (value: unknown): value is Glob =>\n  typeof value === \"object\" && value !== null && \"_tag\" in value && value._tag === \"Glob\"\n\n/**\n * Whether a value carries the `\"TreeArtifact\"` tag. It checks only the tag,\n * not the path.\n *\n * @param value - Any value.\n * @returns `true` for an object whose `_tag` is `\"TreeArtifact\"`.\n * @category guards\n * @since 0.1.0\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/**\n * Whether `path` matches `pattern` under {@link Glob} wildcard rules.\n *\n * The pattern is read in its {@link canonical} spelling; the path is matched\n * as given, case-sensitively, with `/` as its only separator.\n *\n * @param pattern - A Bazel-style pattern such as `src/*.ts` or `docs/**`.\n * @param path - A workspace-relative path.\n * @returns `true` when the path matches.\n * @category predicates\n * @since 0.1.0\n */\nexport const matchesPattern = (pattern: string, path: string): boolean => patternMatcher(pattern)(path)\n\n/**\n * Whether `path` matches some `include` pattern of `glob` and no `exclude`\n * pattern, each tested with {@link matchesPattern}. Case-sensitive.\n *\n * @param glob - The glob to test.\n * @param path - A workspace-relative path.\n * @returns `true` when the glob selects the path.\n * @category predicates\n * @since 0.1.0\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/**\n * Whether a canonical path is inside a declaration, case-sensitively.\n * Unlike {@link overlaps}, this predicate establishes replay authority.\n *\n * @category predicates\n * @since 1.0.0-rc.0\n */\nexport const contains = (entry: Entry, path: string): boolean => {\n  const inside = canonical(path)\n  if (typeof entry === \"string\") return canonical(entry) === inside\n  if (isGlob(entry)) return matchesGlob(entry, inside)\n  const root = canonical(entry.path)\n  return inside === root || inside.startsWith(`${root}/`)\n}\n\n/** Includes fold conservatively; exclusions cannot rule out all case aliases. */\nconst mayMatchGlob = (glob: Glob, path: string): boolean =>\n  glob.include.some((pattern) => matchesPattern(folded(pattern), folded(path)))\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 folds its includes and ignores exclusions: an excluded\n * spelling may alias an included spelling on another filesystem. {@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 */\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 mayMatchGlob(right, left)\n  if (isGlob(left) && typeof right === \"string\") return mayMatchGlob(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"]}

package/dist/esm/GraphBuildError.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+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.
+ *
+ * @param diagnostic - A recorded refusal.
+ * @returns `false` only for an advisory code (`capability_outside_grant`).
+ * @since 0.1.0
+ * @category predicates
+ */
+export declare const isFatalDiagnostic: (diagnostic: GraphBuildError) => boolean;
+export {};
+//# sourceMappingURL=GraphBuildError.d.ts.map

package/dist/esm/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,mBAAmB,ohBAwB9B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;;;;;;;AAEjE;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,eAAgB,SAAQ,oBAKnC;CAAG;AAaL;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,GAAI,YAAY,eAAe,KAAG,OAA8C,CAAA"}