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

package/dist/cjs/FileSet.d.ts

@@ -0,0 +1,366 @@
+/**
+ * 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 declare const BoundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+/**
+ * The value form of {@link BoundaryMode}.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type BoundaryMode = typeof BoundaryMode.Type;
+/**
+ * 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 declare const canonical: (path: string) => string;
+/**
+ * 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 declare const folded: (path: string) => string;
+/**
+ * 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 declare const Pattern: Schema.NonEmptyString;
+/**
+ * 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 declare const workspaceRelative: (pattern: string) => boolean;
+/**
+ * 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 declare const Glob: Schema.TaggedStruct<"Glob", {
+    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+}>;
+/**
+ * The value form of {@link Glob}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Glob = typeof Glob.Type;
+/**
+ * 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 declare const TreeArtifact: Schema.TaggedStruct<"TreeArtifact", {
+    readonly path: Schema.NonEmptyString;
+}>;
+/**
+ * The value form of {@link TreeArtifact}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type TreeArtifact = typeof TreeArtifact.Type;
+/**
+ * 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 declare const Entry: Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+}>, Schema.TaggedStruct<"TreeArtifact", {
+    readonly path: Schema.NonEmptyString;
+}>]>;
+/**
+ * The value form of {@link Entry}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Entry = typeof Entry.Type;
+/**
+ * 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 declare const ReadEntry: Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+}>]>;
+/**
+ * The value form of {@link ReadEntry}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ReadEntry = typeof ReadEntry.Type;
+/**
+ * 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 declare const Filegroup: Schema.TaggedStruct<"Filegroup", {
+    readonly name: Schema.NonEmptyString;
+    readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>, Schema.TaggedStruct<"TreeArtifact", {
+        readonly path: Schema.NonEmptyString;
+    }>]>>;
+}>;
+/**
+ * The value form of {@link Filegroup}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Filegroup = typeof Filegroup.Type;
+/**
+ * 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 declare const ReadFilegroup: Schema.TaggedStruct<"Filegroup", {
+    readonly name: Schema.NonEmptyString;
+    readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>]>>;
+}>;
+/**
+ * The value form of {@link ReadFilegroup}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ReadFilegroup = typeof ReadFilegroup.Type;
+/**
+ * Any declaration accepted in a write set: an {@link Entry} or a
+ * {@link Filegroup}.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Declaration: Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+}>, Schema.TaggedStruct<"TreeArtifact", {
+    readonly path: Schema.NonEmptyString;
+}>]>, Schema.TaggedStruct<"Filegroup", {
+    readonly name: Schema.NonEmptyString;
+    readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>, Schema.TaggedStruct<"TreeArtifact", {
+        readonly path: Schema.NonEmptyString;
+    }>]>>;
+}>]>;
+/**
+ * The value form of {@link Declaration}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Declaration = typeof Declaration.Type;
+/**
+ * Any declaration accepted in a read set: a {@link ReadEntry} or a
+ * {@link ReadFilegroup}.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ReadDeclaration: Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+}>]>, Schema.TaggedStruct<"Filegroup", {
+    readonly name: Schema.NonEmptyString;
+    readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>]>>;
+}>]>;
+/**
+ * The value form of {@link ReadDeclaration}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ReadDeclaration = typeof ReadDeclaration.Type;
+/**
+ * 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 declare const makeFilegroup: (name: string, entries: ReadonlyArray<Entry>) => Filegroup;
+/**
+ * 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 declare const expand: (declarations: ReadonlyArray<Declaration>) => ReadonlyArray<Entry>;
+/**
+ * {@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 declare const expandReads: (declarations: ReadonlyArray<ReadDeclaration>) => ReadonlyArray<ReadEntry>;
+/**
+ * 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 declare const isGlob: (value: unknown) => value is 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 declare const isTreeArtifact: (value: unknown) => value is TreeArtifact;
+/**
+ * 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 declare const matchesPattern: (pattern: string, path: string) => boolean;
+/**
+ * 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 declare const matchesGlob: (glob: Glob, path: string) => boolean;
+/**
+ * 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 declare const contains: (entry: Entry, path: string) => boolean;
+/**
+ * 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 declare const overlaps: (left: Entry, right: Entry) => boolean;
+//# sourceMappingURL=FileSet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileSet.d.ts","sourceRoot":"","sources":["../../src/FileSet.ts"],"names":[],"mappings":"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"}

package/dist/cjs/FileSet.js

@@ -0,0 +1,196 @@
+"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,
+  contains: () => contains,
+  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 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}/`);
+};
+const mayMatchGlob = (glob, path) => glob.include.some((pattern) => matchesPattern(folded(pattern), folded(path)));
+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;
+  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 */\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 \u2014 `.` segments, empty segments \u2014 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"],
+  "mappings": "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",
+  "names": ["matched"]
+}