@nielspeter/eess-ts 0.2.1 → 0.4.0

package/dist/core/glob-diagnosis.d.ts

@@ -0,0 +1,78 @@
+import type { GlobSite } from '@nielspeter/eess';
+import type { PathUniverse } from './path-universe.js';
+import type { DiskSet, OnDisk } from './disk-set.js';
+/**
+ * Why a glob matches nothing.
+ *
+ * Two of these name a cause, and only because the fix is a transformation that
+ * can be *verified*: removing `./`, and adding the `**\/` anchor. A third,
+ * `file-not-folder`, is verifiable in the other direction — the glob matches a
+ * file and no directory, and the predicate reads directories. Everything else
+ * falls into `no-match`, which lists likely causes without asserting one.
+ *
+ * That restraint is deliberate and was learned the hard way. Earlier revisions
+ * asserted a specific cause — "the directory does not exist", "append `/**`" —
+ * and each was false on a reachable input: a glob targeting a file, a
+ * directory whose name ends in `]`, a path that plainly existed. Under ADR-008
+ * a confidently wrong cause is worse than an honest list, because the agent
+ * acts on it.
+ */
+export type GlobFault = 'dot-segment' | 'unanchored' | 'file-not-folder' | 'no-match';
+interface GlobDiagnosis {
+    readonly fault: GlobFault;
+    readonly onDisk?: OnDisk;
+}
+/** Where the glob conventions these messages talk about are documented. */
+export declare const GLOB_DOCS = "https://github.com/nielspeter/eess/blob/main/docs/slices.md";
+/**
+ * Whether a glob can already match an absolute path.
+ *
+ * Defined in `project-relative.ts` and re-exported here, where its callers are.
+ * It has to live at the lower level: `isProjectRelative` is defined as its
+ * negation, and importing it upward from there closed a cycle —
+ * `disk-set -> path-universe -> glob-diagnosis -> project-relative -> project
+ * -> disk-set`, caught by this repository's own `beFreeOfCycles` rule. The
+ * predicate is pure string syntax with no dependencies, so the lower level is
+ * where it belonged anyway.
+ */
+export { isAnchored } from './project-relative.js';
+/**
+ * The faults decidable from the glob string alone, with no project to compare
+ * against.
+ *
+ * Split out because two callers need exactly this and nothing more: the
+ * `assignedFrom()` message, which groups entries by cause before any universe
+ * is available, and `diagnoseGlob` below. One source of truth for the syntax
+ * rules, so the two can never drift into disagreeing about what `./src/**` is.
+ */
+export declare function syntacticFault(glob: string, kind: GlobSite['kind'], base?: GlobSite['base']): 'dot-segment' | 'unanchored' | undefined;
+/**
+ * Diagnose one unsatisfiable glob.
+ *
+ * Call only on a site already known to be dead — this explains a fault, it
+ * does not detect one. Keeping detection (`isDeadSite`) and explanation apart
+ * is what stops the disk walk from ever becoming a *trigger*: a project with
+ * no faults never touches the filesystem.
+ *
+ * Each fault has a different fix, so they are reported separately. A message
+ * that lumps them together, or reports only the first kind it finds, sends the
+ * caller through repeated failing runs.
+ */
+export declare function diagnoseGlob(site: GlobSite, universe: PathUniverse, diskSet?: DiskSet): GlobDiagnosis;
+/**
+ * The remedy for each fault, or an honest list of causes where no remedy is
+ * verifiable.
+ */
+export declare const FAULT_ADVICE: Readonly<Record<GlobFault, string>>;
+/**
+ * What the filesystem adds, when it adds anything.
+ *
+ * Stated as a fact and never as a remedy. Every candidate remedy here is wrong
+ * on a reachable input: "add it to your tsconfig `include`" is wrong for
+ * `dist/`, for codegen output, and absurd for the Rust crate that a real
+ * TypeScript monorepo turned out to contain. So this contributes the fact and
+ * its own two causes, rather than deferring to `no-match`'s list — two of
+ * whose three causes are refuted by the fact printed one line above.
+ */
+export declare const ON_DISK_ADVICE: Readonly<Record<OnDisk, string>>;
+//# sourceMappingURL=glob-diagnosis.d.ts.map

package/dist/core/glob-diagnosis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-diagnosis.d.ts","sourceRoot":"","sources":["../../src/core/glob-diagnosis.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,YAAY,GAAG,iBAAiB,GAAG,UAAU,CAAA;AAErF,UAAU,aAAa;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,2EAA2E;AAC3E,eAAO,MAAM,SAAS,gEAAgE,CAAA;AAEtF;;;;;;;;;;GAUG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAGlD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EACtB,IAAI,GAAE,QAAQ,CAAC,MAAM,CAAc,GAClC,aAAa,GAAG,YAAY,GAAG,SAAS,CAiB1C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,YAAY,EACtB,OAAO,CAAC,EAAE,OAAO,GAChB,aAAa,CAiBf;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAS5D,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoC3D,CAAA"}

package/dist/core/glob-diagnosis.js

@@ -0,0 +1,134 @@
+import picomatch from 'picomatch';
+/** Where the glob conventions these messages talk about are documented. */
+export const GLOB_DOCS = 'https://github.com/nielspeter/eess/blob/main/docs/slices.md';
+/**
+ * Whether a glob can already match an absolute path.
+ *
+ * Defined in `project-relative.ts` and re-exported here, where its callers are.
+ * It has to live at the lower level: `isProjectRelative` is defined as its
+ * negation, and importing it upward from there closed a cycle —
+ * `disk-set -> path-universe -> glob-diagnosis -> project-relative -> project
+ * -> disk-set`, caught by this repository's own `beFreeOfCycles` rule. The
+ * predicate is pure string syntax with no dependencies, so the lower level is
+ * where it belonged anyway.
+ */
+export { isAnchored } from './project-relative.js';
+import { isAnchored } from './project-relative.js';
+/**
+ * The faults decidable from the glob string alone, with no project to compare
+ * against.
+ *
+ * Split out because two callers need exactly this and nothing more: the
+ * `assignedFrom()` message, which groups entries by cause before any universe
+ * is available, and `diagnoseGlob` below. One source of truth for the syntax
+ * rules, so the two can never drift into disagreeing about what `./src/**` is.
+ */
+export function syntacticFault(glob, kind, base = 'absolute') {
+    // A './' anywhere — not just leading — makes the glob unmatchable, and
+    // adding '**/' in front of it does not help ('**/./src/**' still matches
+    // nothing). True for every base.
+    if (/(?:^|\/)\.\//.test(glob))
+        return 'dot-segment';
+    // Exempt for the kinds that are not paths: after the bug 0014 fix,
+    // `notImportFrom('fastify')` is a working rule and `isAnchored('fastify')`
+    // is false.
+    const isPathKind = kind === 'file-path' || kind === 'parent-dir';
+    // And exempt for the bases where a relative glob is the CORRECT spelling.
+    // `slices().matching()` strips and re-adds the anchor, and `resolvers()`
+    // resolves against the tsconfig directory; telling either of them to anchor
+    // would be telling the user to break a working rule.
+    if (isPathKind && base === 'absolute' && !isAnchored(glob))
+        return 'unanchored';
+    return undefined;
+}
+/**
+ * Diagnose one unsatisfiable glob.
+ *
+ * Call only on a site already known to be dead — this explains a fault, it
+ * does not detect one. Keeping detection (`isDeadSite`) and explanation apart
+ * is what stops the disk walk from ever becoming a *trigger*: a project with
+ * no faults never touches the filesystem.
+ *
+ * Each fault has a different fix, so they are reported separately. A message
+ * that lumps them together, or reports only the first kind it finds, sends the
+ * caller through repeated failing runs.
+ */
+export function diagnoseGlob(site, universe, diskSet) {
+    const syntactic = syntacticFault(site.glob, site.kind, site.base);
+    if (syntactic)
+        return { fault: syntactic };
+    // A `parent-dir` glob that matches a FILE and no directory is the
+    // `resideInFolder` mistake: the predicate reads the directory portion, so a
+    // glob written at a file can never match. Verifiable, and therefore safe to
+    // assert — measured instance: '**/src/predicates/module**' matches 1 file
+    // and 0 parent directories.
+    if (site.kind === 'parent-dir' && matchesAny(site.glob, universe.filePaths)) {
+        return { fault: 'file-not-folder' };
+    }
+    if (site.kind === 'file-path' && matchesAny(site.glob, universe.parentDirs)) {
+        return { fault: 'file-not-folder' };
+    }
+    return { fault: 'no-match', onDisk: diskSet?.classify(site.glob) ?? 'not-determined' };
+}
+/**
+ * The remedy for each fault, or an honest list of causes where no remedy is
+ * verifiable.
+ */
+export const FAULT_ADVICE = {
+    'dot-segment': 'a "./" segment never occurs in an absolute file path — remove it and anchor instead ("./src/x/**" -> "**/src/x/**")',
+    unanchored: 'these are matched against ABSOLUTE file paths, so a project-relative glob matches nothing — prefix these with "**/"',
+    'file-not-folder': 'this matches a FILE but is used where a directory is read, so it can never match — use resideInFile() for a file, or append "/**" to name the files inside a directory',
+    'no-match': 'these are anchored but matched no file. Common causes: the glob names a directory rather than the files inside it (append "/**"), a path segment is misspelled, or the directory holds no source files',
+};
+/**
+ * What the filesystem adds, when it adds anything.
+ *
+ * Stated as a fact and never as a remedy. Every candidate remedy here is wrong
+ * on a reachable input: "add it to your tsconfig `include`" is wrong for
+ * `dist/`, for codegen output, and absurd for the Rust crate that a real
+ * TypeScript monorepo turned out to contain. So this contributes the fact and
+ * its own two causes, rather than deferring to `no-match`'s list — two of
+ * whose three causes are refuted by the fact printed one line above.
+ */
+export const ON_DISK_ADVICE = {
+    'holds-typescript': 'this path exists and contains TypeScript, but your tsconfig include/exclude keeps it out of the project',
+    'no-typescript': 'this path exists but contains no TypeScript',
+    // Bug 0032. This was `''`, so a verified absence deferred to `no-match`'s
+    // list — the exact deferral the paragraph above rules out, and two of that
+    // list's three causes are refuted by the fact: there is no directory, so
+    // "append /**" and "holds no source files" are both false.
+    //
+    // TWO CORRECTIONS FROM REVIEW OF THE FIRST FIX, both of which made this
+    // string a new confidently-wrong message while removing an old one:
+    //
+    // 1. It said "nothing matching this exists on disk" — a universal claim the
+    //    walk cannot support. `absent` means "not found in a BOUNDED walk" from
+    //    `discoverIdentityRoot`, with pruned directory names and unreadable
+    //    directories dropped. Measured false on two reachable inputs: a sibling
+    //    package outside the identity root (a monorepo checkout with no `.git`,
+    //    which `identity-root.ts` itself documents), and a real directory whose
+    //    name holds glob metacharacters. So the claim is scoped to the search.
+    // 2. It offered "a folder you have not created yet — banning one
+    //    pre-emptively is legitimate", borrowed from plan 0072. But 0072's case
+    //    is a `notImportFrom`, a CONDITION glob, and `diagnose()` drops
+    //    condition and exclusion positions before reaching here. This string is
+    //    printed only for `selector` and `discovery`, where a glob matching
+    //    nothing means the rule has no subjects — the false green 0069 is named
+    //    after and R3b will fail the build on. It told the agent that was fine.
+    //
+    // The metacharacter cause is `slice-rule-builder.ts`'s, verbatim in
+    // substance, because it already states it for `check` — the same
+    // one-fact-two-texts trap this fix fell into elsewhere.
+    absent: 'no file or directory matching this was found under the project root (build and vendor directories are not searched, so a path inside one is not seen) — a path segment does not match what is on disk, or a literal "(", ")", "{", "}" or "!" in a folder name is being read as pattern syntax rather than a literal character, in which case match that level with "*" instead',
+    // Stays empty, and is NOT the same case as `absent` above despite looking
+    // identical. Here the walk was pruned, so no fact is known — deferring to
+    // `no-match`'s cause list is the honest move rather than a gap.
+    'not-determined': '',
+};
+function matchesAny(glob, candidates) {
+    const isMatch = picomatch(glob);
+    // Never `candidates.some(isMatch)` — picomatch reads the array index as its
+    // second argument and returns a truthy object from index 1 onwards.
+    return candidates.some((candidate) => isMatch(candidate));
+}
+//# sourceMappingURL=glob-diagnosis.js.map

package/dist/core/glob-diagnosis.js.map

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

package/dist/core/glob-evaluator.d.ts

@@ -0,0 +1,48 @@
+import type { GlobNode, GlobSite } from '@nielspeter/eess';
+import type { PathUniverse } from './path-universe.js';
+/**
+ * Whether a glob tree can never match anything in this project.
+ *
+ * Three consecutive revisions of this function returned a false verdict, each
+ * on a shape its author had not thought to try, so it is now checked
+ * exhaustively rather than argued about:
+ * `tests/core/glob-evaluator-soundness.test.ts` enumerates every expression of
+ * at most three combinator nodes over {dead, live, opaque} and compares this
+ * implementation against plain set semantics. The requirement is **soundness**
+ * — a fault is justified only if the expression selects the empty set for
+ * every possible value of the leaves this function cannot see, since all it
+ * knows is that a dead site matches nothing.
+ *
+ * The three rules, and what each one is load-bearing for:
+ *
+ * - **A negative site is never dead.** `not(unsatisfiable)` selects
+ *   *everything*; that is over-selection, not vacuity.
+ * - **An opaque leaf is never dead**, and is never dropped. See `OpaqueGlob`.
+ * - **`all` is dead if any child is; `any` is dead only if every child is.**
+ *   Which is why `negateGlobs` has to invert `op` and not just polarity.
+ */
+export declare function isDeadGlobTree(node: GlobNode, universe: PathUniverse): boolean;
+/**
+ * Whether one site's glob matches nothing in the project.
+ *
+ * Two independent ways to be dead, and both are needed:
+ *
+ * 1. **Syntactically** — `'src/domain/**'` on a predicate that matches
+ *    absolute paths can never match, whatever the project contains.
+ * 2. **Against the universe** — anchored, well-formed, and nothing there.
+ *
+ * The syntactic check is not redundant, and leaving it out was a live false
+ * green caught by a test: the universe carries a tsconfig-relative view so
+ * that a wrong `base` cannot make a glob look UNmatched — and `'src/domain/**'`
+ * matches `src/domain` in that view while matching nothing at runtime, where
+ * `resideInFolder` reads absolute paths. Unanchored globs are the commonest
+ * real mistake and the entire subject of the 0.18.1 release, so a design that
+ * quietly calls them satisfiable defeats its own purpose.
+ *
+ * Only `file-path` and `parent-dir` are checkable; `viewsFor` returns no views
+ * for the others, and a site with no views is never dead.
+ */
+export declare function isDeadSite(site: GlobSite, universe: PathUniverse): boolean;
+/** Every site in a tree, in declaration order. Opaque leaves are skipped. */
+export declare function globSitesOf(node: GlobNode): GlobSite[];
+//# sourceMappingURL=glob-evaluator.d.ts.map

package/dist/core/glob-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-evaluator.d.ts","sourceRoot":"","sources":["../../src/core/glob-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAY,QAAQ,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAItD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAQ9E;AAQD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAS1E;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAUtD"}

package/dist/core/glob-evaluator.js

@@ -0,0 +1,89 @@
+import picomatch from 'picomatch';
+import { isGlobNode, isOpaqueGlob } from '@nielspeter/eess';
+import { viewsFor } from './path-universe.js';
+import { syntacticFault } from './glob-diagnosis.js';
+/**
+ * Whether a glob tree can never match anything in this project.
+ *
+ * Three consecutive revisions of this function returned a false verdict, each
+ * on a shape its author had not thought to try, so it is now checked
+ * exhaustively rather than argued about:
+ * `tests/core/glob-evaluator-soundness.test.ts` enumerates every expression of
+ * at most three combinator nodes over {dead, live, opaque} and compares this
+ * implementation against plain set semantics. The requirement is **soundness**
+ * — a fault is justified only if the expression selects the empty set for
+ * every possible value of the leaves this function cannot see, since all it
+ * knows is that a dead site matches nothing.
+ *
+ * The three rules, and what each one is load-bearing for:
+ *
+ * - **A negative site is never dead.** `not(unsatisfiable)` selects
+ *   *everything*; that is over-selection, not vacuity.
+ * - **An opaque leaf is never dead**, and is never dropped. See `OpaqueGlob`.
+ * - **`all` is dead if any child is; `any` is dead only if every child is.**
+ *   Which is why `negateGlobs` has to invert `op` and not just polarity.
+ */
+export function isDeadGlobTree(node, universe) {
+    return node.op === 'all'
+        ? node.children.some((child) => isDeadChild(child, universe))
+        : // `every` on an empty array is `true`, which would fault a rule that
+            // declares no globs at all. Unreachable, because every combinator
+            // contributes one child per input and a missing declaration becomes an
+            // opaque leaf rather than nothing — but stated, not assumed.
+            node.children.length > 0 && node.children.every((child) => isDeadChild(child, universe));
+}
+function isDeadChild(child, universe) {
+    if (isGlobNode(child))
+        return isDeadGlobTree(child, universe);
+    if (isOpaqueGlob(child))
+        return false;
+    return isDeadSite(child, universe);
+}
+/**
+ * Whether one site's glob matches nothing in the project.
+ *
+ * Two independent ways to be dead, and both are needed:
+ *
+ * 1. **Syntactically** — `'src/domain/**'` on a predicate that matches
+ *    absolute paths can never match, whatever the project contains.
+ * 2. **Against the universe** — anchored, well-formed, and nothing there.
+ *
+ * The syntactic check is not redundant, and leaving it out was a live false
+ * green caught by a test: the universe carries a tsconfig-relative view so
+ * that a wrong `base` cannot make a glob look UNmatched — and `'src/domain/**'`
+ * matches `src/domain` in that view while matching nothing at runtime, where
+ * `resideInFolder` reads absolute paths. Unanchored globs are the commonest
+ * real mistake and the entire subject of the 0.18.1 release, so a design that
+ * quietly calls them satisfiable defeats its own purpose.
+ *
+ * Only `file-path` and `parent-dir` are checkable; `viewsFor` returns no views
+ * for the others, and a site with no views is never dead.
+ */
+export function isDeadSite(site, universe) {
+    if ((site.polarity ?? 'positive') === 'negative')
+        return false;
+    const views = viewsFor(universe, site.kind);
+    if (views.length === 0)
+        return false;
+    if (syntacticFault(site.glob, site.kind, site.base) !== undefined)
+        return true;
+    const isMatch = picomatch(site.glob);
+    // Never `view.some(isMatch)` — picomatch reads the array index as its
+    // second argument and returns a truthy object from index 1 onwards.
+    return !views.some((view) => view.some((candidate) => isMatch(candidate)));
+}
+/** Every site in a tree, in declaration order. Opaque leaves are skipped. */
+export function globSitesOf(node) {
+    const sites = [];
+    const walk = (current) => {
+        for (const child of current.children) {
+            if (isGlobNode(child))
+                walk(child);
+            else if (!isOpaqueGlob(child))
+                sites.push(child);
+        }
+    };
+    walk(node);
+    return sites;
+}
+//# sourceMappingURL=glob-evaluator.js.map

package/dist/core/glob-evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-evaluator.js","sourceRoot":"","sources":["../../src/core/glob-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,WAAW,CAAA;AAEjC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,cAAc,CAAC,IAAc,EAAE,QAAsB;IACnE,OAAO,IAAI,CAAC,EAAE,KAAK,KAAK;QACtB,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC7D,CAAC,CAAC,qEAAqE;YACrE,kEAAkE;YAClE,uEAAuE;YACvE,6DAA6D;YAC7D,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAA;AAC9F,CAAC;AAED,SAAS,WAAW,CAAC,KAAoC,EAAE,QAAsB;IAC/E,IAAI,UAAU,CAAC,KAAK,CAAC;QAAE,OAAO,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;IAC7D,IAAI,YAAY,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IACrC,OAAO,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,UAAU,CAAC,IAAc,EAAE,QAAsB;IAC/D,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,UAAU,CAAC,KAAK,UAAU;QAAE,OAAO,KAAK,CAAA;IAC9D,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;IAC3C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IACpC,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IAC9E,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACpC,sEAAsE;IACtE,oEAAoE;IACpE,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;AAC5E,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,WAAW,CAAC,IAAc;IACxC,MAAM,KAAK,GAAe,EAAE,CAAA;IAC5B,MAAM,IAAI,GAAG,CAAC,OAAiB,EAAQ,EAAE;QACvC,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrC,IAAI,UAAU,CAAC,KAAK,CAAC;gBAAE,IAAI,CAAC,KAAK,CAAC,CAAA;iBAC7B,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;gBAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAClD,CAAC;IACH,CAAC,CAAA;IACD,IAAI,CAAC,IAAI,CAAC,CAAA;IACV,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/core/import-candidates.d.ts

@@ -0,0 +1,60 @@
+import type picomatch from 'picomatch';
+import type { ImportDeclaration } from 'ts-morph';
+/**
+ * Every string an import glob may be matched against, primary first.
+ *
+ * Non-empty by construction, and `[0]` is the primary — see `importCandidates`.
+ */
+type ImportCandidates = readonly [primary: string, ...alternates: string[]];
+/**
+ * Every string a glob may legitimately be matched against for one import.
+ *
+ * The old rule was "the resolved path, **or** the raw specifier if it does not
+ * resolve" — which is backwards. An installed package with types resolves, so
+ * `notImportFrom('fastify')` was compared against
+ * `/…/node_modules/@types/fastify/index.d.ts` and never matched. The documented
+ * way to ban a dependency worked only on dependencies you had not installed
+ * (bug 0014).
+ *
+ * So: match against **both**, and a glob matches the import if it matches
+ * either. Path globs keep working, because the resolved path is still tested.
+ *
+ * The specifier is offered only when it is **non-relative**. A relative
+ * specifier (`'../services/foo.js'`) carries no information the resolved path
+ * lacks, and testing it as a string would let `'**\/services/**'` match an
+ * import that resolves somewhere else entirely. Bare package names and path
+ * aliases (`'@/lib/x'`) are the cases this exists for, and both are
+ * non-relative.
+ *
+ * **`[0]` is the primary candidate, and it is exactly what the old
+ * `resolveImportPath` returned.** That is load-bearing rather than incidental:
+ * violation messages interpolate it, `hashViolation` hashes the message, and a
+ * changed message silently invalidates every baselined dependency violation.
+ * Keeping the primary stable means only genuinely *new* findings get new text.
+ * A test asserts the equivalence across the whole fixture corpus.
+ */
+export declare function importCandidates(decl: ImportDeclaration): ImportCandidates;
+/**
+ * The same candidates, from the two values a `ModuleEdge` already carries.
+ *
+ * This is why `ModuleEdge` has **no `candidates` field** (plan 0071 §1):
+ * candidates are a function of `specifier` and `resolvedPath`, so storing them
+ * beside their own two inputs would be two representations of one fact, free to
+ * disagree. The function is exposed instead.
+ *
+ * `importCandidates` above is now a thin wrapper over this, which is what lets
+ * `tests/core/module-edges-corpus.test.ts` compare the two derivations across
+ * the whole repository: same rule, reached from a declaration on one side and
+ * from an edge on the other.
+ */
+export declare function candidatesFor(specifier: string, resolvedPath: string | undefined, projectRoot?: string): ImportCandidates;
+/**
+ * The first candidate matching any matcher, or `undefined` if none do.
+ *
+ * "First" is what keeps messages stable: the primary is tested before the
+ * specifier, so an import that already matched on its resolved path reports
+ * the same string it reported before this fix.
+ */
+export declare function matchedCandidate(candidates: ImportCandidates, matchers: readonly picomatch.Matcher[]): string | undefined;
+export {};
+//# sourceMappingURL=import-candidates.d.ts.map

package/dist/core/import-candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-candidates.d.ts","sourceRoot":"","sources":["../../src/core/import-candidates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,WAAW,CAAA;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD;;;;GAIG;AACH,KAAK,gBAAgB,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,UAAU,EAAE,MAAM,EAAE,CAAC,CAAA;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,gBAAgB,CAK1E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,WAAW,CAAC,EAAE,MAAM,GACnB,gBAAgB,CAsBlB;AASD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,SAAS,SAAS,CAAC,OAAO,EAAE,GACrC,MAAM,GAAG,SAAS,CAIpB"}

package/dist/core/import-candidates.js

@@ -0,0 +1,93 @@
+/**
+ * Every string a glob may legitimately be matched against for one import.
+ *
+ * The old rule was "the resolved path, **or** the raw specifier if it does not
+ * resolve" — which is backwards. An installed package with types resolves, so
+ * `notImportFrom('fastify')` was compared against
+ * `/…/node_modules/@types/fastify/index.d.ts` and never matched. The documented
+ * way to ban a dependency worked only on dependencies you had not installed
+ * (bug 0014).
+ *
+ * So: match against **both**, and a glob matches the import if it matches
+ * either. Path globs keep working, because the resolved path is still tested.
+ *
+ * The specifier is offered only when it is **non-relative**. A relative
+ * specifier (`'../services/foo.js'`) carries no information the resolved path
+ * lacks, and testing it as a string would let `'**\/services/**'` match an
+ * import that resolves somewhere else entirely. Bare package names and path
+ * aliases (`'@/lib/x'`) are the cases this exists for, and both are
+ * non-relative.
+ *
+ * **`[0]` is the primary candidate, and it is exactly what the old
+ * `resolveImportPath` returned.** That is load-bearing rather than incidental:
+ * violation messages interpolate it, `hashViolation` hashes the message, and a
+ * changed message silently invalidates every baselined dependency violation.
+ * Keeping the primary stable means only genuinely *new* findings get new text.
+ * A test asserts the equivalence across the whole fixture corpus.
+ */
+// eess-exclude eess/no-unused-exports: consumed by the test suite; the build tsconfig this gate reads excludes tests, so `src` is the only usage it can see
+export function importCandidates(decl) {
+    return candidatesFor(decl.getModuleSpecifierValue(), decl.getModuleSpecifierSourceFile()?.getFilePath());
+}
+/**
+ * The same candidates, from the two values a `ModuleEdge` already carries.
+ *
+ * This is why `ModuleEdge` has **no `candidates` field** (plan 0071 §1):
+ * candidates are a function of `specifier` and `resolvedPath`, so storing them
+ * beside their own two inputs would be two representations of one fact, free to
+ * disagree. The function is exposed instead.
+ *
+ * `importCandidates` above is now a thin wrapper over this, which is what lets
+ * `tests/core/module-edges-corpus.test.ts` compare the two derivations across
+ * the whole repository: same rule, reached from a declaration on one side and
+ * from an edge on the other.
+ */
+export function candidatesFor(specifier, resolvedPath, projectRoot) {
+    if (resolvedPath === undefined)
+        return [specifier];
+    const alternates = isRelativeSpecifier(specifier) ? [] : [specifier];
+    // The resolved path named from the project root, **appended** — bug 0037.
+    //
+    // An import glob is matched against an ABSOLUTE resolved path, so a
+    // project-relative one could never match it: measured,
+    // `layeredArchitecture({ shared: ['src/shared/**'] })` reported a violation
+    // on a correct architecture, because `shared` also reaches
+    // `onlyImportFrom(...)`. A **false red**, with no configuration finding and a
+    // silent `doctor` — worse than a false green for an agent, which will edit
+    // real imports to satisfy a broken allowlist.
+    //
+    // Appended, never prepended: `[0]` is the primary candidate that violation
+    // messages interpolate and `hashViolation` hashes, so putting the relative
+    // form first would rewrite every baselined dependency finding.
+    //
+    // Bare specifiers are untouched — they have no `resolvedPath`, and returning
+    // early above is what keeps `notImportFrom('fastify')` working (bug 0014).
+    const fromRoot = relativeTo(projectRoot, resolvedPath);
+    if (fromRoot !== undefined)
+        alternates.push(fromRoot);
+    return [resolvedPath, ...alternates];
+}
+/** `absolutePath` named from `root`, or `undefined` when it is outside or unknown. */
+function relativeTo(root, absolutePath) {
+    if (root === undefined)
+        return undefined;
+    const prefix = root === '/' ? '/' : `${root}/`;
+    return absolutePath.startsWith(prefix) ? absolutePath.slice(prefix.length) : undefined;
+}
+/**
+ * The first candidate matching any matcher, or `undefined` if none do.
+ *
+ * "First" is what keeps messages stable: the primary is tested before the
+ * specifier, so an import that already matched on its resolved path reports
+ * the same string it reported before this fix.
+ */
+export function matchedCandidate(candidates, matchers) {
+    // Never `candidates.some(matcher)` — picomatch reads the array index as its
+    // second argument and returns a truthy object from index 1 on.
+    return candidates.find((candidate) => matchers.some((isMatch) => isMatch(candidate)));
+}
+/** A specifier that names a location relative to the importing file. */
+function isRelativeSpecifier(specifier) {
+    return specifier.startsWith('.') || specifier.startsWith('/');
+}
+//# sourceMappingURL=import-candidates.js.map

package/dist/core/import-candidates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-candidates.js","sourceRoot":"","sources":["../../src/core/import-candidates.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4JAA4J;AAC5J,MAAM,UAAU,gBAAgB,CAAC,IAAuB;IACtD,OAAO,aAAa,CAClB,IAAI,CAAC,uBAAuB,EAAE,EAC9B,IAAI,CAAC,4BAA4B,EAAE,EAAE,WAAW,EAAE,CACnD,CAAA;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,SAAiB,EACjB,YAAgC,EAChC,WAAoB;IAEpB,IAAI,YAAY,KAAK,SAAS;QAAE,OAAO,CAAC,SAAS,CAAC,CAAA;IAClD,MAAM,UAAU,GAAa,mBAAmB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;IAC9E,0EAA0E;IAC1E,EAAE;IACF,oEAAoE;IACpE,uDAAuD;IACvD,4EAA4E;IAC5E,2DAA2D;IAC3D,8EAA8E;IAC9E,2EAA2E;IAC3E,8CAA8C;IAC9C,EAAE;IACF,2EAA2E;IAC3E,2EAA2E;IAC3E,+DAA+D;IAC/D,EAAE;IACF,6EAA6E;IAC7E,2EAA2E;IAC3E,MAAM,QAAQ,GAAG,UAAU,CAAC,WAAW,EAAE,YAAY,CAAC,CAAA;IACtD,IAAI,QAAQ,KAAK,SAAS;QAAE,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IACrD,OAAO,CAAC,YAAY,EAAE,GAAG,UAAU,CAAC,CAAA;AACtC,CAAC;AAED,sFAAsF;AACtF,SAAS,UAAU,CAAC,IAAwB,EAAE,YAAoB;IAChE,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAA;IACxC,MAAM,MAAM,GAAG,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAA;IAC9C,OAAO,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AACxF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAA4B,EAC5B,QAAsC;IAEtC,4EAA4E;IAC5E,+DAA+D;IAC/D,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;AACvF,CAAC;AAED,wEAAwE;AACxE,SAAS,mBAAmB,CAAC,SAAiB;IAC5C,OAAO,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;AAC/D,CAAC"}

package/dist/core/import-options.d.ts

@@ -1,4 +1,4 @@
-import type { ImportDeclaration } from 'ts-morph';
+import type { ExportDeclaration, ImportDeclaration } from 'ts-morph';
 /**
  * Options for import-related conditions and predicates.
  */
@@ -10,7 +10,11 @@ export interface ImportOptions {
      * Type-only imports are erased at compile time and create no runtime dependency.
      * Useful for layer isolation rules where type-sharing is acceptable.
      *
-     * Default: false (all imports checked, for backward compatibility).
+     * Default: **per condition.** `false` — count every import — for `dependOn`,
+     * `importFrom`, `notImportFrom`, `onlyImportFrom`, `notDependOn` and
+     * `respectLayerOrder`, which ask whether the code is *coupled*. `true` for
+     * `beFreeOfCycles`, which asks whether the module is *evaluated*: an erased import
+     * cannot contribute to an initialization cycle. See `docs/slices.md`.
      */
     ignoreTypeImports?: boolean;
 }
@@ -29,4 +33,53 @@ export interface ImportOptions {
  * - `import * as Foo from '...'` (namespace import is runtime)
  */
 export declare function isTypeOnlyImport(decl: ImportDeclaration): boolean;
+/**
+ * Check whether a re-export is purely type-only (no runtime dependency).
+ *
+ * The `export … from` analogue of {@link isTypeOnlyImport}, and **both halves of
+ * the disjunction are needed** — measured, the two spellings put the flag in
+ * different places:
+ *
+ * | form                            | `decl.isTypeOnly()` | specifiers |
+ * | ------------------------------- | ------------------- | ---------- |
+ * | `export type { X } from 's'`    | **true**            | false      |
+ * | `export { type X } from 's'`    | false               | **true**   |
+ * | `export type * from 's'`        | **true**            | (none)     |
+ * | `export { X } from 's'`         | false               | false      |
+ *
+ * No default or namespace analogue exists, verified: there is no way to write a
+ * re-export that binds a runtime value while every named specifier is
+ * type-only, so this needs none of {@link isTypeOnlyImport}'s guards. A bare
+ * `export * from 's'` has no named specifiers and is runtime, which is why the
+ * second half requires a non-empty list.
+ */
+export declare function isTypeOnlyReExport(decl: ExportDeclaration): boolean;
+/**
+ * Split a variadic glob API's arguments, without a type assertion.
+ *
+ * Five entry points take `...args: [string[], ImportOptions] | string[]` —
+ * `onlyImportFrom`, `notImportFrom`, `dependOn`, `importFrom`, `importFromAny` —
+ * so a caller can write either `f('a', 'b')` or `f(['a', 'b'], { … })`. TypeScript
+ * cannot narrow a tuple-union rest parameter from `Array.isArray(args[0])`, which
+ * is true and was the stated reason for **ten** `as` casts across three files:
+ *
+ * ```ts
+ * const globs: string[] = Array.isArray(args[0]) ? args[0] : (args as string[])
+ * const options = Array.isArray(args[0]) && args.length > 1 ? (args[1] as ImportOptions) : undefined
+ * ```
+ *
+ * [ADR-005](../../../../adr/005-no-any-no-type-assertions.md) prescribes a type guard,
+ * and a guard does narrow it: `.filter((a): a is string => …)` produces `string[]`
+ * with no assertion, and `typeof second === 'object'` narrows the options. The
+ * casts were avoidable; only the direct narrowing was not.
+ *
+ * One owner rather than five copies, which is the other half. The dispatch was
+ * duplicated five times, and a duplicated predicate in this repo has already
+ * caused a measurement error once —
+ * [ts-archunit bug 0044](https://github.com/nielspeter/ts-archunit/blob/main/bugs/fixed/0044-an-inline-exclusion-comment-has-no-feedback-channel.md).
+ */
+export declare function splitGlobArgs(args: readonly (string[] | ImportOptions | string)[]): {
+    globs: string[];
+    options: ImportOptions | undefined;
+};
 //# sourceMappingURL=import-options.d.ts.map

package/dist/core/import-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-options.d.ts","sourceRoot":"","sources":["../../src/core/import-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAUjE"}
+{"version":3,"file":"import-options.d.ts","sourceRoot":"","sources":["../../src/core/import-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEpE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAUjE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAInE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,aAAa,GAAG,MAAM,CAAC,EAAE,GAAG;IACnF,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,OAAO,EAAE,aAAa,GAAG,SAAS,CAAA;CACnC,CAcA"}