@shrkcrft/boundaries 0.1.0-alpha.29 → 0.1.0-alpha.31

package/dist/wiring/plan-wiring-fix.js

@@ -1,6 +1,8 @@
-import { matchesAny } from "../scan/glob.js";
-import { escapeRegex, scanBalanced } from "../extract/scan-literals.js";
+import { globListSelects } from "../scan/glob.js";
+import { elementToken, escapeRegex, scanBalanced } from "../extract/scan-literals.js";
+import { extractTokens } from "../extract/extract-tokens.js";
 import { registeredSources } from "./evaluate-wiring.js";
+import { collectSinkBindings, deriveImportTemplate, insertImportStatement, renderImport, renderSpecifier, } from "./sink-imports.js";
 import { resolveExtractorAnchor, resolveExtractorKind } from '@shrkcrft/core';
 export const WIRING_FIX_SCHEMA = 'sharkcraft.wiring-fix/v1';
 /** Indentation of the line containing `index`. */
@@ -17,6 +19,134 @@ function lineOf(content, index) {
     }
     return line;
 }
+/** Extensions a derived specifier may resolve through, in probe order. */
+const RESOLVE_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
+/**
+ * Resolve a relative specifier against the sink's directory, POSIX-style.
+ *
+ * Only relative specifiers are resolvable this way. A bare specifier is a
+ * package (or a tsconfig alias) whose target this engine cannot know without a
+ * resolver, so those are reported unresolved and the caller refuses.
+ */
+function resolveRelative(sinkPath, specifier) {
+    if (!specifier.startsWith('.'))
+        return undefined;
+    const dir = sinkPath.includes('/') ? sinkPath.slice(0, sinkPath.lastIndexOf('/')) : '';
+    const parts = [...dir.split('/').filter(Boolean), ...specifier.split('/')];
+    const stack = [];
+    for (const part of parts) {
+        if (part === '' || part === '.')
+            continue;
+        if (part === '..') {
+            if (stack.length === 0)
+                return undefined;
+            stack.pop();
+            continue;
+        }
+        stack.push(part);
+    }
+    return stack.join('/');
+}
+/**
+ * Whether a derived specifier really points at the file that DECLARES the
+ * token.
+ *
+ * This is the safety net that makes the derived-import path trustworthy rather
+ * than merely plausible. The template says what the specifier *should* be; this
+ * confirms it names the file the gate found the token in. A template that
+ * happens to fit the existing members but misses for the new one is caught
+ * here instead of being written to disk.
+ */
+function specifierPointsAtDeclaration(sinkPath, specifier, declaringFile) {
+    const base = resolveRelative(sinkPath, specifier);
+    if (base === undefined)
+        return false;
+    if (base === declaringFile)
+        return true;
+    for (const ext of RESOLVE_EXTENSIONS) {
+        if (base + ext === declaringFile)
+            return true;
+        if (`${base}/index${ext}` === declaringFile)
+            return true;
+    }
+    return false;
+}
+/**
+ * Whether `file` exports `token`, per the same extractor the declared side of a
+ * rule most often uses.
+ *
+ * Reuses `extractTokens` rather than a second regex so "what counts as an
+ * export" has exactly one definition — a private answer here that drifted from
+ * the extractor would either block valid fixes or wave through invalid ones.
+ */
+function exportsToken(content, token) {
+    const res = extractTokens({ files: ['*'], extract: 'export-names' }, [{ path: 'x', content }]);
+    return res.sites.some((site) => site.token === token);
+}
+/**
+ * Decide whether appending `token` to the sink needs an import, and whether
+ * that import can be derived.
+ *
+ * The condition is an INCONSISTENCY check, not a resolvability check. An import
+ * is needed exactly when the sink's existing members are import-bound but the
+ * new token would not be — that is the case where the append introduces a
+ * reference the file cannot resolve, and where the gate would go green over a
+ * file that no longer compiles.
+ *
+ * Deliberately NOT "the token must be bound". If the existing members are
+ * themselves unbound (ambient globals, a `/// <reference>`, a fixture), then
+ * whatever makes them resolve applies equally to the new one, and the append is
+ * consistent with the file's own convention. Refusing there would be a false
+ * refusal on a file the edit does not make any worse.
+ */
+function decideImport(sinkPath, sinkContent, members, token, declaringFile, declaringContent) {
+    const bindings = collectSinkBindings(sinkContent);
+    // Already resolvable here — imported, or declared inline in the sink.
+    if (bindings.some((b) => b.local === token))
+        return { kind: 'append-only' };
+    // Only members brought in by an IMPORT establish a binding convention the new
+    // token has to follow. A locally-declared member says nothing about where an
+    // external one would come from.
+    const importedMembers = members.filter((m) => bindings.some((b) => b.local === m && b.kind !== 'local'));
+    // No member arrives by import, so there is no convention the new token is
+    // breaking — the append leaves the file exactly as consistent as it was.
+    if (importedMembers.length === 0)
+        return { kind: 'append-only' };
+    const template = deriveImportTemplate(sinkContent, members);
+    if (!template) {
+        return {
+            kind: 'refuse',
+            detail: `sink ${sinkPath} imports its members, but their import paths are not a function of the member name ` +
+                '(a barrel, mixed paths, or an aliased import) — the specifier for this token cannot be derived',
+        };
+    }
+    if (declaringFile === undefined) {
+        return {
+            kind: 'refuse',
+            detail: `sink ${sinkPath} imports its members and the declaring file of "${token}" is unknown, so the import cannot be verified`,
+        };
+    }
+    // A named import only works if the target actually EXPORTS the token. The
+    // gate may have found it with any extractor (`regex-capture` over `const (\w+)`
+    // matches un-exported locals too), so being declared there does not imply
+    // being exported from there.
+    if (declaringContent !== undefined && !exportsToken(declaringContent, token)) {
+        return {
+            kind: 'refuse',
+            detail: `"${token}" is declared in ${declaringFile} but not exported from it — ` +
+                'a named import would not resolve, so the array append is refused too',
+        };
+    }
+    const specifier = renderSpecifier(template, token);
+    if (!specifierPointsAtDeclaration(sinkPath, specifier, declaringFile)) {
+        return {
+            kind: 'refuse',
+            detail: `sink ${sinkPath} imports its members; the derived specifier "${specifier}" does not resolve to ` +
+                `${declaringFile}, where "${token}" is declared — refusing rather than writing a guess`,
+        };
+    }
+    return { kind: 'derived', template, statement: renderImport(template, token) };
+}
 /**
  * Plan the mechanically-unambiguous fixes for `declared-but-not-registered`
  * violations.
@@ -57,7 +187,7 @@ export function planWiringFix(rule, violations, files) {
     const anchor = resolveExtractorAnchor(sink);
     if (anchor === undefined)
         return refuseAll('sink-not-an-array', 'sink declares no anchor');
-    const sinkFiles = files.filter((f) => matchesAny(f.path, sink.files ?? []));
+    const sinkFiles = files.filter((f) => globListSelects(f.path, sink.files ?? []));
     if (sinkFiles.length !== 1) {
         return refuseAll('ambiguous-sink-file', `sink glob matched ${sinkFiles.length} files — the insertion point must be unique`);
     }
@@ -99,6 +229,25 @@ export function planWiringFix(rule, violations, files) {
         }
         const open = mm.index + mm[0].length - 1;
         const scan = scanBalanced(content, open);
+        // Decide the IMPORT before touching the array. An append that leaves the
+        // token unbound compiles-fails, and a gate that goes green by breaking the
+        // build is worse than one that refuses — so a token we cannot bind is
+        // skipped with the reason, never half-written.
+        const currentMembers = scan.elements
+            .map((el) => elementToken(el.text))
+            .filter((t) => t !== undefined);
+        const decision = quoted
+            ? { kind: 'append-only' } // string members bind nothing
+            : decideImport(target.path, content, currentMembers, v.token, v.file, v.file ? files.find((f) => f.path === v.file)?.content : undefined);
+        if (decision.kind === 'refuse') {
+            skipped.push({
+                ruleId: rule.id,
+                token: v.token,
+                reason: 'needs-import',
+                detail: decision.detail,
+            });
+            continue;
+        }
         insertAt = scan.end;
         const last = scan.elements[scan.elements.length - 1];
         const indent = last ? indentOf(content, last.index) : '  ';
@@ -116,13 +265,37 @@ export function planWiringFix(rule, violations, files) {
             ? `${needsComma ? ',' : ''}\n${indent}${rendered},`
             : `${needsComma ? ', ' : ''}${rendered}`;
         content = content.slice(0, cut) + insert + tail + content.slice(insertAt);
+        const arrayLine = lineOf(content, cut + insert.length);
+        // Add the derived import LAST, so the array line number reported above is
+        // computed before the insertion shifts it — the two edits are reported
+        // against the file the reviewer will actually see.
+        let importInsert;
+        let importLine;
+        if (decision.kind === 'derived') {
+            const inserted = insertImportStatement(content, decision.statement);
+            if (!inserted) {
+                // Unreachable in practice (a template implies an import exists), but a
+                // planner that silently dropped the import would reintroduce the bug.
+                skipped.push({
+                    ruleId: rule.id,
+                    token: v.token,
+                    reason: 'needs-import',
+                    detail: `could not locate an import block in ${target.path} to extend`,
+                });
+                continue;
+            }
+            content = inserted.nextContent;
+            importInsert = decision.statement;
+            importLine = inserted.line;
+        }
         edits.push({
             ruleId: rule.id,
             token: v.token,
             file: target.path,
-            line: lineOf(content, cut + insert.length),
+            line: arrayLine,
             insert: insert.trim(),
             nextContent: content,
+            ...(importInsert !== undefined ? { importInsert, importLine: importLine } : {}),
         });
     }
     return { schema: WIRING_FIX_SCHEMA, edits, skipped };

package/dist/wiring/registration-graph.d.ts

@@ -1,4 +1,5 @@
-import type { IRegistrationIdiom } from '@shrkcrft/core';
+import { type IRegistrationIdiom } from '@shrkcrft/core';
+import type { IReadScope } from '../util/read-scope.js';
 import { type IWiringFileEntry } from './evaluate-wiring.js';
 export declare const REGISTRATION_GRAPH_SCHEMA: "sharkcraft.registration-graph/v1";
 /** A token role-site: which idiom + file:line it was found at. */
@@ -31,6 +32,13 @@ export interface IRegistrationGraph {
     readonly tokens: readonly IRegistrationNode[];
     /** Misconfiguration messages (bad regex / no capture group / bad source). */
     readonly diagnostics: readonly string[];
+    /**
+     * Set only when a file an idiom's globs matched was NOT read (over the read
+     * cap, or unreadable): the files read, and the unread ones. A token declared,
+     * provided or consumed only there is missing from `tokens`, so an
+     * "unprovided" or "orphan" answer over them proves nothing.
+     */
+    readonly readScope?: IReadScope;
 }
 export interface IBuildRegistrationGraphOptions {
     /** Project-relative directories to prune from the walk. */
@@ -53,6 +61,10 @@ export declare function buildRegistrationGraph(projectRoot: string, idioms: read
  * persisted registration-graph cache — a source edit shifts the signature even
  * when no reindex has run, so a stale wiring verdict is impossible. Walk-and-stat
  * only (no file reads), so it stays far cheaper than a full build. Never throws.
+ *
+ * It signs the POSITIVE union walk, not each role's selected set: a file a
+ * role's `!` excludes still shifts the signature. That over-inclusion can only
+ * cause a spurious cache miss — the safe direction — never a stale verdict.
  */
 export declare function registrationGraphSignature(projectRoot: string, idioms: readonly IRegistrationIdiom[], options?: IBuildRegistrationGraphOptions): string;
 /**

package/dist/wiring/registration-graph.d.ts.map

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

package/dist/wiring/registration-graph.js

@@ -1,8 +1,10 @@
 import { createHash } from 'node:crypto';
 import { statSync } from 'node:fs';
 import * as nodePath from 'node:path';
-import { matchesAny } from "../scan/glob.js";
+import { resolveSourceGlobs } from '@shrkcrft/core';
+import { globListSelects } from "../scan/glob.js";
 import { readMatchingFiles, walkMatching } from "../util/walk-files.js";
+import { readScopeOfLists } from "../util/read-scope-coverage.js";
 import { collectSourceSites } from "./evaluate-wiring.js";
 export const REGISTRATION_GRAPH_SCHEMA = 'sharkcraft.registration-graph/v1';
 function sortSites(sites) {
@@ -11,7 +13,11 @@ function sortSites(sites) {
 /** Union (deduped) of every glob any role of any idiom references. */
 function registrationGlobs(idioms) {
     return [
-        ...new Set(idioms.flatMap((i) => [...i.declared.files, ...i.provided.files, ...i.consumed.files])),
+        ...new Set(idioms.flatMap((i) => [
+            ...resolveSourceGlobs(i.declared),
+            ...resolveSourceGlobs(i.provided),
+            ...resolveSourceGlobs(i.consumed),
+        ])),
     ];
 }
 /**
@@ -23,12 +29,14 @@ function registrationGlobs(idioms) {
  * diagnostic.
  */
 export function buildRegistrationGraph(projectRoot, idioms, options = {}) {
-    const cache = readMatchingFiles(projectRoot, registrationGlobs(idioms), new Set(options.excludeDirs ?? []));
-    const entries = [...cache.entries()].map(([path, content]) => ({
+    const matched = readMatchingFiles(projectRoot, registrationGlobs(idioms), new Set(options.excludeDirs ?? []));
+    const entries = [...matched.files.entries()].map(([path, content]) => ({
         path,
         content,
     }));
-    const filesFor = (source) => entries.filter((f) => matchesAny(f.path, source.files));
+    // The walk is the POSITIVE union of every role of every idiom; each role
+    // selects its own files, so one role's `!x` never hides another role's file.
+    const filesFor = (source) => entries.filter((f) => globListSelects(f.path, resolveSourceGlobs(source)));
     const declared = new Map();
     const provided = new Map();
     const consumed = new Map();
@@ -55,11 +63,15 @@ export function buildRegistrationGraph(projectRoot, idioms, options = {}) {
         provided: sortSites(provided.get(token) ?? []),
         consumed: sortSites(consumed.get(token) ?? []),
     }));
+    // Read scope PER ROLE LIST (one file counted once): an unread file every
+    // role that could reach it EXCLUDES is out of scope, not a gap.
+    const scope = readScopeOfLists(matched, idioms.flatMap((i) => [i.declared, i.provided, i.consumed].map((s) => resolveSourceGlobs(s))));
     return {
         schema: REGISTRATION_GRAPH_SCHEMA,
         idioms: idioms.map((i) => i.name),
         tokens,
         diagnostics,
+        ...(scope.unread.length > 0 ? { readScope: scope } : {}),
     };
 }
 /**
@@ -70,6 +82,10 @@ export function buildRegistrationGraph(projectRoot, idioms, options = {}) {
  * persisted registration-graph cache — a source edit shifts the signature even
  * when no reindex has run, so a stale wiring verdict is impossible. Walk-and-stat
  * only (no file reads), so it stays far cheaper than a full build. Never throws.
+ *
+ * It signs the POSITIVE union walk, not each role's selected set: a file a
+ * role's `!` excludes still shifts the signature. That over-inclusion can only
+ * cause a spurious cache miss — the safe direction — never a stale verdict.
  */
 export function registrationGraphSignature(projectRoot, idioms, options = {}) {
     const files = walkMatching(projectRoot, registrationGlobs(idioms), new Set(options.excludeDirs ?? [])).sort();
@@ -96,7 +112,7 @@ export function registrationGraphSignature(projectRoot, idioms, options = {}) {
 export function providedTokensFromEntries(idioms, entries) {
     const tokens = new Set();
     for (const idiom of idioms) {
-        const files = entries.filter((f) => matchesAny(f.path, idiom.provided.files));
+        const files = entries.filter((f) => globListSelects(f.path, resolveSourceGlobs(idiom.provided)));
         for (const s of collectSourceSites(idiom.provided, files).sites)
             tokens.add(s.token);
     }

package/dist/wiring/registration-query-verdict.d.ts

@@ -0,0 +1,23 @@
+import { type IRegistrationIdiom, type IVerdictCoverage } from '@shrkcrft/core';
+import type { IIdiomRoleCoverage } from './i-idiom-role-coverage.js';
+import type { IRegistrationQueryVerdict } from './i-registration-query-verdict.js';
+import { type IOrphanRegistration, type IRegistrationGraph, type IUnprovidedToken } from './registration-graph.js';
+/**
+ * THE registration graph's read-scope record: the idiom files the reader could
+ * not read, named (`examined 3 of 4 files, 1 over the 1MB read cap: …`), or
+ * `undefined` when it read every file its idioms matched. `wiring unprovided |
+ * orphans`, finish's unprovided sub-gate and MCP `get_wiring_graph` all read
+ * it here, so the verb and its siblings cannot disagree about what was read.
+ */
+export declare function registrationGraphCoverage(graph: IRegistrationGraph): IVerdictCoverage | undefined;
+/**
+ * `wiring unprovided` settled against what the graph read AND what every
+ * idiom's roles examined (`roles`: `measureIdiomRoleCoverage`, THE role
+ * authority — required, so no surface can forget the fold). `extra` adds
+ * candidates found another way (finish's base-ref provider regressions); they
+ * are merged by token and sorted, as finish always did.
+ */
+export declare function registrationUnprovidedVerdict(graph: IRegistrationGraph, idioms: readonly IRegistrationIdiom[], roles: readonly IIdiomRoleCoverage[], changedFiles?: readonly string[], extra?: readonly IUnprovidedToken[]): IRegistrationQueryVerdict<IUnprovidedToken>;
+/** `wiring orphans` settled against what the graph read and what every idiom's roles examined. */
+export declare function registrationOrphansVerdict(graph: IRegistrationGraph, idioms: readonly IRegistrationIdiom[], roles: readonly IIdiomRoleCoverage[], changedFiles?: readonly string[]): IRegistrationQueryVerdict<IOrphanRegistration>;
+//# sourceMappingURL=registration-query-verdict.d.ts.map

package/dist/wiring/registration-query-verdict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration-query-verdict.d.ts","sourceRoot":"","sources":["../../src/wiring/registration-query-verdict.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AAKjC;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,SAAS,CASjG;AAwFD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,SAAS,kBAAkB,EAAE,EACrC,KAAK,EAAE,SAAS,kBAAkB,EAAE,EACpC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,EAChC,KAAK,CAAC,EAAE,SAAS,gBAAgB,EAAE,GAClC,yBAAyB,CAAC,gBAAgB,CAAC,CAQ7C;AAED,kGAAkG;AAClG,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,SAAS,kBAAkB,EAAE,EACrC,KAAK,EAAE,SAAS,kBAAkB,EAAE,EACpC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,GAC/B,yBAAyB,CAAC,mBAAmB,CAAC,CAUhD"}

package/dist/wiring/registration-query-verdict.js

@@ -0,0 +1,118 @@
+import { coverageShortfall, resolveSourceGlobs, ruleVerdictRecords, } from '@shrkcrft/core';
+import { describeUnread, readScopeCoverage, unreadMatching } from "../util/read-scope-coverage.js";
+import { registrationOrphans, registrationUnprovided, } from "./registration-graph.js";
+/** At most this many demoted tokens ride on one coverage record. */
+const TOKEN_LABEL_CAP = 20;
+/**
+ * THE registration graph's read-scope record: the idiom files the reader could
+ * not read, named (`examined 3 of 4 files, 1 over the 1MB read cap: …`), or
+ * `undefined` when it read every file its idioms matched. `wiring unprovided |
+ * orphans`, finish's unprovided sub-gate and MCP `get_wiring_graph` all read
+ * it here, so the verb and its siblings cannot disagree about what was read.
+ */
+export function registrationGraphCoverage(graph) {
+    if (!graph.readScope || graph.readScope.unread.length === 0)
+        return undefined;
+    return {
+        ...readScopeCoverage({ unit: 'registration idioms', expected: graph.idioms.length, examined: graph.idioms.length }, graph.readScope),
+        subject: 'registration graph',
+    };
+}
+/**
+ * Every idiom's role records, as an absence query settles them (round 13, P4):
+ * the role authority's coverage (`examined 2 of 3 roles … declared (0 files)`)
+ * plus its expectEmpty acceptance, folded by core's `ruleVerdictRecords` and
+ * subject-prefixed with the idiom. A role record that is only the idiom's read
+ * gap is dropped while the graph's own read-scope record is carried — that
+ * record already names every unread idiom file (a union over idioms); its
+ * acceptance is kept, so a record B is never dropped silently.
+ */
+function roleRecords(graph, roles) {
+    const graphNamesUnread = registrationGraphCoverage(graph) !== undefined;
+    return roles.flatMap((r) => {
+        const records = graphNamesUnread && r.readGap
+            ? r.unitAcceptance
+                ? [r.unitAcceptance]
+                : []
+            : ruleVerdictRecords(r.coverage, r.unitAcceptance);
+        return records.map((c) => ({ ...c, subject: c.subject ?? r.idiom }));
+    });
+}
+/**
+ * THE rule for an absence claim over an incomplete read. The graph merges
+ * tokens across idioms, so a site of the missing role in ANY idiom satisfies a
+ * token. When an unread file matches any idiom's `missingRole` globs, every
+ * candidate could be refuted there: all are demoted to `unproven`, named in a
+ * second coverage record. Otherwise the candidates are findings.
+ *
+ * Round 13 (P4): every idiom's ROLE coverage is carried too, always — the
+ * graph's read scope said nothing about a role whose globs matched no file, so
+ * "every declared token has a provider" printed a ✓ over a declared role that
+ * examined nothing. A dead role never demotes a candidate (a finding stays a
+ * finding, as on `gates check`); it keeps a clean answer from being a pass.
+ */
+function absenceVerdict(graph, idioms, roles, missingRole, candidates, unit, subject) {
+    const unread = graph.readScope?.unread ?? [];
+    // Per idiom's role LIST, never a flattened union: a negation subtracts from
+    // its own list only, so one idiom's `!x` cannot hide a refuting file from
+    // another idiom that reads it. Deduped by path, sorted.
+    const refutingByPath = new Map();
+    for (const i of unread.length > 0 ? idioms : []) {
+        for (const u of unreadMatching(unread, resolveSourceGlobs(i[missingRole]))) {
+            if (!refutingByPath.has(u.path))
+                refutingByPath.set(u.path, u);
+        }
+    }
+    const refuting = [...refutingByPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+    const unproven = refuting.length > 0 ? candidates : [];
+    const fileRecord = registrationGraphCoverage(graph);
+    const coverage = [
+        ...(fileRecord ? [fileRecord] : []),
+        ...roleRecords(graph, roles),
+        ...(unproven.length > 0
+            ? [
+                {
+                    unit,
+                    expected: unproven.length,
+                    examined: 0,
+                    unexamined: unproven.slice(0, TOKEN_LABEL_CAP).map((t) => t.token),
+                    unexaminedTotal: unproven.length,
+                    reason: `may be ${missingRole} in a file the reader did not read — ${describeUnread(refuting)}`,
+                    subject,
+                },
+            ]
+            : []),
+    ];
+    return {
+        findings: refuting.length > 0 ? [] : candidates,
+        unproven,
+        coverage,
+        shortfalls: coverage.flatMap((c) => {
+            const s = coverageShortfall(c);
+            return s === undefined ? [] : [s];
+        }),
+        unread,
+    };
+}
+/**
+ * `wiring unprovided` settled against what the graph read AND what every
+ * idiom's roles examined (`roles`: `measureIdiomRoleCoverage`, THE role
+ * authority — required, so no surface can forget the fold). `extra` adds
+ * candidates found another way (finish's base-ref provider regressions); they
+ * are merged by token and sorted, as finish always did.
+ */
+export function registrationUnprovidedVerdict(graph, idioms, roles, changedFiles, extra) {
+    let candidates = registrationUnprovided(graph, changedFiles);
+    if (extra !== undefined) {
+        const byToken = new Map();
+        for (const u of [...candidates, ...extra])
+            if (!byToken.has(u.token))
+                byToken.set(u.token, u);
+        candidates = [...byToken.values()].sort((a, b) => a.token.localeCompare(b.token));
+    }
+    return absenceVerdict(graph, idioms, roles, 'provided', candidates, 'unprovided tokens', 'unprovided');
+}
+/** `wiring orphans` settled against what the graph read and what every idiom's roles examined. */
+export function registrationOrphansVerdict(graph, idioms, roles, changedFiles) {
+    return absenceVerdict(graph, idioms, roles, 'consumed', registrationOrphans(graph, changedFiles), 'orphan registrations', 'orphans');
+}

package/dist/wiring/registry-query.d.ts

@@ -1,4 +1,5 @@
-import type { IRegistryDeclaration } from '@shrkcrft/core';
+import { type IRegistryDeclaration } from '@shrkcrft/core';
+import type { IReadScope } from '../util/read-scope.js';
 export declare const REGISTRY_SCHEMA: "sharkcraft.registry-inventory/v1";
 /** Where an id was found (project-relative path + 1-based line). */
 export interface IRegistrySite {
@@ -22,6 +23,13 @@ export interface IRegistryInventory {
     readonly entries: readonly IRegistryEntry[];
     /** Misconfiguration messages (bad regex / no capture group / bad source). */
     readonly diagnostics: readonly string[];
+    /**
+     * The SOURCE side's read scope: declaration files read, and matched ones the
+     * reader did not read (over the read cap, or unreadable). With any unread
+     * the inventory is incomplete: an absent id, "no duplicates" or an empty
+     * inventory proves nothing.
+     */
+    readonly readScope: IReadScope;
 }
 export interface IScanRegistryOptions {
     /** Project-relative directories to prune from the walk. */

package/dist/wiring/registry-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry-query.d.ts","sourceRoot":"","sources":["../../src/wiring/registry-query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAK3D,eAAO,MAAM,eAAe,EAAG,kCAA2C,CAAC;AAE3E,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACnD;AAED,0EAA0E;AAC1E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,OAAO,eAAe,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,oBAAoB;IACnC,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAMD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,oBAAoB,EAC1B,OAAO,GAAE,oBAAyB,GACjC,kBAAkB,CA+CpB;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,SAAS,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAEjF;AAED,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,SAAS,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEnG;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,GAAG,SAAS,cAAc,EAAE,CAE3F"}
+{"version":3,"file":"registry-query.d.ts","sourceRoot":"","sources":["../../src/wiring/registry-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAG/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAIxD,eAAO,MAAM,eAAe,EAAG,kCAA2C,CAAC;AAE3E,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACnD;AAED,0EAA0E;AAC1E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,OAAO,eAAe,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAMD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,oBAAoB,EAC1B,OAAO,GAAE,oBAAyB,GACjC,kBAAkB,CAwDpB;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,SAAS,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAEjF;AAED,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,SAAS,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEnG;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,GAAG,SAAS,cAAc,EAAE,CAE3F"}

package/dist/wiring/registry-query.js

@@ -1,5 +1,7 @@
-import { matchesAny } from "../scan/glob.js";
+import { resolveSourceGlobs } from '@shrkcrft/core';
+import { globListSelects } from "../scan/glob.js";
 import { readMatchingFiles } from "../util/walk-files.js";
+import { unreadMatching } from "../util/read-scope-coverage.js";
 import { collectSourceSites } from "./evaluate-wiring.js";
 export const REGISTRY_SCHEMA = 'sharkcraft.registry-inventory/v1';
 function sortSites(sites) {
@@ -12,18 +14,23 @@ function sortSites(sites) {
  */
 export function scanRegistry(projectRoot, decl, options = {}) {
     const globs = [
-        ...new Set([...decl.source.files, ...(decl.consumer ? decl.consumer.files : [])]),
+        ...new Set([
+            ...resolveSourceGlobs(decl.source),
+            ...(decl.consumer ? resolveSourceGlobs(decl.consumer) : []),
+        ]),
     ];
-    const cache = readMatchingFiles(projectRoot, globs, new Set(options.excludeDirs ?? []));
-    const entries = [...cache.entries()].map(([path, content]) => ({ path, content }));
+    const matched = readMatchingFiles(projectRoot, globs, new Set(options.excludeDirs ?? []));
+    const entries = [...matched.files.entries()].map(([path, content]) => ({ path, content }));
     const diagnostics = [];
-    const sourceFiles = entries.filter((f) => matchesAny(f.path, decl.source.files));
+    // The walk above is the POSITIVE union of both sides; each side selects its
+    // own files, so the source's `!` never hides a consumer file (or vice versa).
+    const sourceFiles = entries.filter((f) => globListSelects(f.path, resolveSourceGlobs(decl.source)));
     const declared = collectSourceSites(decl.source, sourceFiles);
     if (declared.error)
         diagnostics.push(`registry "${decl.name}" source: ${declared.error}`);
     const consumerByToken = new Map();
     if (decl.consumer) {
-        const consumerFiles = entries.filter((f) => matchesAny(f.path, decl.consumer.files));
+        const consumerFiles = entries.filter((f) => globListSelects(f.path, resolveSourceGlobs(decl.consumer)));
         const consumed = collectSourceSites(decl.consumer, consumerFiles);
         if (consumed.error)
             diagnostics.push(`registry "${decl.name}" consumer: ${consumed.error}`);
@@ -53,6 +60,10 @@ export function scanRegistry(projectRoot, decl, options = {}) {
         ...(decl.description ? { description: decl.description } : {}),
         entries: entriesOut,
         diagnostics,
+        readScope: {
+            read: sourceFiles.length,
+            unread: unreadMatching(matched.unread, resolveSourceGlobs(decl.source)),
+        },
     };
 }
 /** True if `id` is declared in the registry (alias-blind exact membership). */

package/dist/wiring/scan-wiring-files.d.ts

@@ -1,4 +1,4 @@
-import type { IWiringRule } from '@shrkcrft/core';
+import { type IWiringRule } from '@shrkcrft/core';
 import { type IWiringReport } from './evaluate-wiring.js';
 export interface IRunWiringOptions {
     /** Only run rules touched by these (project-relative) changed files. */
@@ -12,8 +12,10 @@ export interface IRunWiringOptions {
 }
 /**
  * Filesystem-backed wiring run: walks the project once, reads only the files a
- * rule references (skipping oversized files), and evaluates every (selected)
- * rule. Pure-engine output; the only IO is the read-only tree walk + reads.
+ * rule references, and evaluates every (selected) rule. A matched file the
+ * reader could not read (over the read cap) is handed to the engine as
+ * unread, so the rule's coverage names it instead of passing over it.
+ * Pure-engine output; the only IO is the read-only tree walk + reads.
  */
 export declare function runWiring(projectRoot: string, rules: readonly IWiringRule[], options?: IRunWiringOptions): IWiringReport;
 //# sourceMappingURL=scan-wiring-files.d.ts.map

package/dist/wiring/scan-wiring-files.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan-wiring-files.d.ts","sourceRoot":"","sources":["../../src/wiring/scan-wiring-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGlD,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAO9B,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,iGAAiG;IACjG,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,2FAA2F;IAC3F,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,OAAO,GAAE,iBAAsB,GAC9B,aAAa,CA+Bf"}
+{"version":3,"file":"scan-wiring-files.d.ts","sourceRoot":"","sources":["../../src/wiring/scan-wiring-files.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAQ3F,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAQ9B,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,iGAAiG;IACjG,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,2FAA2F;IAC3F,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,OAAO,GAAE,iBAAsB,GAC9B,aAAa,CAsEf"}