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

package/dist/wiring/explain-wiring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"explain-wiring.d.ts","sourceRoot":"","sources":["../../src/wiring/explain-wiring.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,gBAAgB,CAAC;AAGjE,OAAO,EAOL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,qBAAqB,EAAG,8BAAuC,CAAC;AAE7E,sFAAsF;AACtF,MAAM,WAAW,kBAAkB;IACjC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC5C,kFAAkF;IAClF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;IAChD,QAAQ,CAAC,cAAc,EAAE,OAAO,GAAG,cAAc,CAAC;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,oFAAoF;IACpF,QAAQ,CAAC,qBAAqB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC5D,yFAAyF;IACzF,QAAQ,CAAC,qBAAqB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC5D,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC9C,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC5C,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;IAC3D,yDAAyD;IACzD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAC;IACjD,yEAAyE;IACzE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,qBAAqB;IACpC,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAQD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,WAAW,EACjB,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAyEhB"}
+{"version":3,"file":"explain-wiring.d.ts","sourceRoot":"","sources":["../../src/wiring/explain-wiring.ts"],"names":[],"mappings":"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"}

package/dist/wiring/explain-wiring.js

@@ -1,7 +1,26 @@
-import { matchesAny } from "../scan/glob.js";
+import { coverageAcceptance, coverageShortfall, normalizeWiringRule, settleRuleStatus, } from '@shrkcrft/core';
+import { sourceLivenessRequest } from "../extract/source-liveness-request.js";
+import { globListSelects } from "../scan/glob.js";
+import { globListUnits } from "../util/dead-glob-units.js";
+import { settleGlobLists } from "../util/settle-glob-lists.js";
 import { readMatchingFiles } from "../util/walk-files.js";
+import { unreadMatching } from "../util/read-scope-coverage.js";
 import { collectSourceSites, evaluateWiring, registeredSources, wiringGlobsOf, wiringSourceSide, } from "./evaluate-wiring.js";
+import { wiringLabeledSources } from "./wiring-labeled-sources.js";
 export const WIRING_EXPLAIN_SCHEMA = 'sharkcraft.wiring-explain/v1';
+/**
+ * The zone the registered side extracted under — only when EVERY sink agrees on
+ * a non-default one. Reporting one sink's zone as the side's would be a claim
+ * the explain cannot back.
+ */
+function registeredScanZone(sources) {
+    if (sources.length === 0)
+        return undefined;
+    const first = sources[0].scan ?? 'all';
+    if (first === 'all')
+        return undefined;
+    return sources.every((s) => (s.scan ?? 'all') === first) ? first : undefined;
+}
 function sortSites(sites) {
     return [...sites].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.token.localeCompare(b.token));
 }
@@ -14,19 +33,49 @@ function sortSites(sites) {
  * committing a rule. The diff/verdict reuse {@link evaluateWiring} so they match
  * the gate exactly (incl. `groupBy` membership). Never throws.
  */
-export function explainWiring(projectRoot, rule, options = {}) {
+/**
+ * The extractor a rule's registered side resolved from — only when EVERY sink
+ * shares it. A union of sinks where one is shared and another is inline has no
+ * single answer, and naming just one would be a claim the config does not make.
+ */
+function registeredExtractorRef(rule) {
+    const sinks = Array.isArray(rule.registered)
+        ? rule.registered
+        : rule.registered
+            ? [rule.registered]
+            : [];
+    if (sinks.length === 0)
+        return undefined;
+    const first = sinks[0].$use;
+    return first !== undefined && sinks.every((s) => s.$use === first) ? first : undefined;
+}
+export function explainWiring(projectRoot, authored, options = {}) {
+    // The engine entry normalises idempotently (round 13): a loaded rule comes
+    // back equal; a hand-built `{ pattern, expectEmpty }` entry (`wiring test`,
+    // `gates try`) becomes a glob plus a marker. A MALFORMED entry is reported
+    // the way the engine reports it — a misconfigured rule — and never reaches
+    // a glob reader (it crashed `wiring test` with `glob.startsWith is not a
+    // function`).
+    const normalized = normalizeWiringRule(authored);
+    if (!normalized.ok)
+        return misconfiguredExplain(authored, evaluateWiring([authored], () => []));
+    const rule = normalized.value;
+    const excludeDirs = options.excludeDirs ?? [];
     const sourceSide = wiringSourceSide(rule);
     // For a chain, the reported "registered" side is the LAST hop (the far end).
     const sinkSources = rule.chain && rule.chain.length >= 2
         ? [rule.chain[rule.chain.length - 1]]
         : registeredSources(rule.registered);
     const allGlobs = [...new Set(wiringGlobsOf(rule))];
-    const cache = readMatchingFiles(projectRoot, allGlobs, new Set(options.excludeDirs ?? []));
-    const entries = [...cache.entries()].map(([path, content]) => ({
+    const matched = readMatchingFiles(projectRoot, allGlobs, 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 ?? []));
+    const filesFor = (source) => entries.filter((f) => globListSelects(f.path, source.files ?? []));
+    // The same unread list the check hands its engine, so the explain's coverage
+    // (read off the engine, never recomputed) names the same unread files.
+    const unreadFor = (source) => unreadMatching(matched.unread, source.files ?? []);
     const declaredFiles = sourceSide ? filesFor(sourceSide) : [];
     const declaredRes = sourceSide
         ? collectSourceSites(sourceSide, declaredFiles)
@@ -34,6 +83,7 @@ export function explainWiring(projectRoot, rule, options = {}) {
     const registeredFiles = new Set();
     const registeredSites = [];
     let registeredError;
+    let registeredBlanked = 0;
     for (const source of sinkSources) {
         const files = filesFor(source);
         for (const f of files)
@@ -41,15 +91,40 @@ export function explainWiring(projectRoot, rule, options = {}) {
         const res = collectSourceSites(source, files);
         if (res.error && !registeredError)
             registeredError = res.error;
+        if (res.blankedChars !== undefined)
+            registeredBlanked += res.blankedChars;
         registeredSites.push(...res.sites);
     }
-    // Canonical diff + counts + verdict from the gate engine (same groupBy logic).
-    const report = evaluateWiring([rule], filesFor);
+    // Canonical diff + counts + verdict from the gate engine (same groupBy logic),
+    // handed the SAME hooks `runWiring` gives it (round 13): which negations
+    // emptied a source, and every source's glob units settled with their
+    // `expectEmpty` markers (`sourceLivenessRequest` over the engine's side
+    // labels). An explained rule is therefore accepted, skipped or failed exactly
+    // as `check wiring` settles it — a planned rule the check accepts used to
+    // explain as "SKIPPED … Verdict: errors" (`check wiring --explain` exit 1,
+    // `gates try` 2).
+    const walked = entries.map((f) => f.path);
+    const unitsOf = (globs) => globListUnits(walked, matched.unread, globs);
+    const report = evaluateWiring([rule], filesFor, {}, unreadFor, (source) => {
+        const units = unitsOf(source.files ?? []);
+        return units.allExcluded ? units.negations : undefined;
+    }, (r) => settleGlobLists(sourceLivenessRequest(projectRoot, wiringLabeledSources(r), excludeDirs, r.id, unitsOf)));
     const ruleResult = report.rules[0];
     const byDirection = (d) => sortSites((ruleResult?.violations ?? [])
         .filter((v) => v.direction === d)
         .map((v) => ({ token: v.token, file: v.file, line: v.line })));
     const skip = report.skipped[0];
+    // The engine's coverage, read — never recomputed — and settled with the SAME
+    // core functions the gate envelope uses: a `passed` rule with a shortfall is
+    // `partial`, and a non-`errors` verdict over a shortfall is `not-verified`.
+    const coverage = ruleResult?.coverage ?? {
+        unit: 'declared tokens',
+        expected: 0,
+        examined: 0,
+        reason: 'the rule did not run',
+    };
+    const shortfall = coverageShortfall(coverage);
+    const acceptance = coverageAcceptance(coverage);
     return {
         schema: WIRING_EXPLAIN_SCHEMA,
         ruleId: rule.id,
@@ -63,20 +138,71 @@ export function explainWiring(projectRoot, rule, options = {}) {
             distinctCount: ruleResult?.declaredCount ?? 0,
             filesScanned: declaredFiles.length,
             ...(declaredRes.error ? { error: declaredRes.error } : {}),
+            ...(rule.declared?.$use ? { viaExtractor: rule.declared.$use } : {}),
+            ...(sourceSide?.scan && sourceSide.scan !== 'all'
+                ? { scan: sourceSide.scan, blankedChars: declaredRes.blankedChars ?? 0 }
+                : {}),
         },
         registered: {
             sites: sortSites(registeredSites),
             distinctCount: ruleResult?.registeredCount ?? 0,
             filesScanned: registeredFiles.size,
             ...(registeredError ? { error: registeredError } : {}),
+            ...(registeredExtractorRef(rule) ? { viaExtractor: registeredExtractorRef(rule) } : {}),
+            ...(registeredScanZone(sinkSources)
+                ? { scan: registeredScanZone(sinkSources), blankedChars: registeredBlanked }
+                : {}),
         },
         declaredNotRegistered: byDirection('declared-missing'),
-        registeredNotDeclared: byDirection('registered-missing'),
+        // Read, never recomputed: the engine's ONE registered-minus-declared set —
+        // parity's violations and subset's coverage shortfall are the same set.
+        registeredNotDeclared: sortSites((ruleResult?.registeredOnly ?? []).map((s) => ({ token: s.token, file: s.file, line: s.line }))),
         overlap: byDirection('overlap'),
         ...(ruleResult?.hops ? { hops: ruleResult.hops } : {}),
-        status: ruleResult?.status ?? 'error',
+        status: settleRuleStatus(ruleResult?.status ?? 'error', coverage),
         ...(skip ? { skipReason: skip.reason } : {}),
-        verdict: report.verdict,
+        verdict: report.verdict !== 'errors' && shortfall !== undefined ? 'not-verified' : report.verdict,
+        coverage,
+        ...(shortfall !== undefined ? { shortfall } : {}),
+        ...(acceptance !== undefined ? { acceptance } : {}),
+        ...(ruleResult?.unitAcceptance !== undefined ? { unitAcceptance: ruleResult.unitAcceptance } : {}),
+        ...(ruleResult?.units !== undefined ? { units: ruleResult.units } : {}),
+        ...(ruleResult?.unitLiveness !== undefined ? { unitLiveness: ruleResult.unitLiveness } : {}),
+        diagnostics: report.diagnostics,
+    };
+}
+/**
+ * The explain of a rule whose markable list is malformed (round 13): the
+ * engine's own misconfigured result (`evaluateWiring` normalises at entry and
+ * reports the bad entry), with empty sides — no glob reader ever sees it.
+ */
+function misconfiguredExplain(rule, report) {
+    const ruleResult = report.rules[0];
+    const coverage = ruleResult?.coverage ?? {
+        unit: 'declared tokens',
+        expected: 0,
+        examined: 0,
+        reason: 'the rule did not run',
+    };
+    const shortfall = coverageShortfall(coverage);
+    const error = report.diagnostics[0] ?? ruleResult?.error ?? 'the rule is misconfigured';
+    return {
+        schema: WIRING_EXPLAIN_SCHEMA,
+        ruleId: rule.id,
+        ...(rule.description ? { description: rule.description } : {}),
+        mode: rule.mode ?? 'subset',
+        registeredMode: rule.registeredMode ?? 'union',
+        ...(rule.groupBy ? { groupBy: rule.groupBy } : {}),
+        severity: rule.severity ?? 'error',
+        declared: { sites: [], distinctCount: 0, filesScanned: 0, error },
+        registered: { sites: [], distinctCount: 0, filesScanned: 0 },
+        declaredNotRegistered: [],
+        registeredNotDeclared: [],
+        overlap: [],
+        status: settleRuleStatus(ruleResult?.status ?? 'error', coverage),
+        verdict: report.verdict !== 'errors' && shortfall !== undefined ? 'not-verified' : report.verdict,
+        coverage,
+        ...(shortfall !== undefined ? { shortfall } : {}),
         diagnostics: report.diagnostics,
     };
 }

package/dist/wiring/i-idiom-role-coverage.d.ts

@@ -0,0 +1,24 @@
+import type { IVerdictCoverage } from '@shrkcrft/core';
+/**
+ * One registration idiom's role coverage, as the registration-graph QUERIES
+ * fold it (round 13, P4): `wiring unprovided | orphans`, finish's unprovided
+ * sub-gate and MCP `get_wiring_graph`. Measured by THE role authority
+ * (`measureRegistrationRoles`, the one `gates check` / `gates coverage` read),
+ * so an absence query can no longer print a ✓ over a declared / provided /
+ * consumed role that matched no file.
+ */
+export interface IIdiomRoleCoverage {
+    /** The idiom's `name` — the subject its records are settled under. */
+    readonly idiom: string;
+    /** `measureRegistrationRoles(...).coverage` — `examined N of 3 roles`, or the read-scope record. */
+    readonly coverage: IVerdictCoverage;
+    /** Its settle record B (`IRegistrationRoles.unitAcceptance`), when a role unit is marked expectEmpty. */
+    readonly unitAcceptance?: IVerdictCoverage;
+    /**
+     * A role left a matched file unread, so {@link coverage} is the read-scope
+     * record — the graph's own read-scope record names the same files, so a
+     * query that carries that record drops this one rather than name them twice.
+     */
+    readonly readGap: boolean;
+}
+//# sourceMappingURL=i-idiom-role-coverage.d.ts.map

package/dist/wiring/i-idiom-role-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-idiom-role-coverage.d.ts","sourceRoot":"","sources":["../../src/wiring/i-idiom-role-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,oGAAoG;IACpG,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,yGAAyG;IACzG,QAAQ,CAAC,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B"}

package/dist/wiring/i-idiom-role-coverage.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,38 @@
+import type { IVerdictCoverage } from '@shrkcrft/core';
+import type { IUnreadFile } from '../util/unread-file.js';
+/**
+ * What a registration-graph ABSENCE query proves over what the graph READ.
+ *
+ * `wiring unprovided` claims "no provider anywhere"; `wiring orphans` claims
+ * "no consumer anywhere". Both are claims about files the graph never saw
+ * when an idiom glob matched a file over the read cap. So an absence whose
+ * missing site could sit in such a file is demoted from a finding to
+ * `unproven`, and the demoted tokens are named in the coverage. The same rule
+ * the registry plane applies: only a positive finding survives an incomplete
+ * inventory.
+ */
+export interface IRegistrationQueryVerdict<T extends {
+    readonly token: string;
+}> {
+    /** Absences the read proves: no unread file could hold the missing site. */
+    readonly findings: readonly T[];
+    /**
+     * Candidates an unread file could refute: the missing role's globs match a
+     * file the reader did not read. Never a finding, and never a pass.
+     */
+    readonly unproven: readonly T[];
+    /**
+     * What to settle against: the graph's read scope (the unread files, named),
+     * every idiom's ROLE records (round 13, P4 — `examined 2 of 3 roles …
+     * declared (0 files)`, plus any expectEmpty acceptance; subject = the
+     * idiom), and, when candidates were demoted, the demoted tokens. Never
+     * empty when an idiom was measured: a role that examined nothing is a
+     * shortfall here exactly as on `gates check`.
+     */
+    readonly coverage: readonly IVerdictCoverage[];
+    /** Core's `coverageShortfall` of each record, in order. */
+    readonly shortfalls: readonly string[];
+    /** Every file the idioms matched that the reader did not read. */
+    readonly unread: readonly IUnreadFile[];
+}
+//# sourceMappingURL=i-registration-query-verdict.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"i-registration-query-verdict.d.ts","sourceRoot":"","sources":["../../src/wiring/i-registration-query-verdict.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,yBAAyB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE;IAC7E,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,CAAC;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC/C,2DAA2D;IAC3D,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;CACzC"}

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

@@ -0,0 +1 @@
+export {};

package/dist/wiring/i-registration-roles.d.ts

@@ -0,0 +1,71 @@
+import type { ISettledUnitLiveness, IVerdictCoverage } from '@shrkcrft/core';
+import type { ISourceInspection } from '../extract/inspect-source.js';
+/**
+ * What each of a registration idiom's three roles extracted from the live tree:
+ * THE answer to "is this idiom empty?" and "which of its roles examined
+ * nothing?".
+ *
+ * `gates check` (the violation check) and `gates coverage` (the stale-selector
+ * detector) both read this one measurement. Before it existed they answered
+ * "empty" differently: check keyed on the union of every role's tokens, while
+ * coverage keyed on the declared role. So a failOnEmpty idiom whose declared
+ * glob had moved FAILED coverage while check printed a ✓ over the same tree.
+ *
+ * Round 13 (P4): it lives in @shrkcrft/boundaries (it moved down from the CLI's
+ * gates, which re-export it) so the registration-graph QUERIES read it too —
+ * `wiring unprovided | orphans`, finish's unprovided sub-gate and MCP
+ * `get_wiring_graph`, which cannot import the CLI. They printed a ✓ over an
+ * idiom whose declared role matched no file while `gates check` said NOT
+ * VERIFIED on the same tree.
+ */
+export interface IRegistrationRoles {
+    /** The DECLARED role, the idiom's primary selector. Its ids are what a selfTest asserts on. */
+    readonly declared: ISourceInspection;
+    readonly provided: ISourceInspection;
+    readonly consumed: ISourceInspection;
+    /**
+     * True when the declared role extracted 0 tokens. That is the idiom's
+     * "matched nothing", as every other plane defines it on its primary selector.
+     * A role error takes precedence: see {@link error}.
+     */
+    readonly empty: boolean;
+    /**
+     * Roles that examined nothing, each labelled with its cause. The causes are
+     * `declared (0 tokens)`, `provided (0 files)` and `consumed (could not run: …)`.
+     *
+     * A provided or consumed role that scanned files but extracted no token is
+     * NOT listed. Nothing provided is exactly the state the unprovided check
+     * reports as a finding, and nothing consumed is an ordinary intermediate
+     * state. A role whose globs matched no file at all examined nothing, though.
+     * Every "unprovided" verdict over a dead provided role comes from a stale
+     * input.
+     */
+    readonly unexamined: readonly string[];
+    /** The first role that could not run, as `<role>: <error>`. */
+    readonly error?: string;
+    /** Where each role's error came from, so a caller can keep its own primary-side rule. */
+    readonly roleErrors: Readonly<Partial<Record<'declared' | 'provided' | 'consumed', string>>>;
+    /**
+     * `{ unit: 'roles', expected: 3, examined: 3 - unexamined }`. A dead role
+     * therefore settles the rule to `partial` (2) in every verb that reads it,
+     * and never to a ✓.
+     */
+    readonly coverage: IVerdictCoverage;
+    /**
+     * Settle record B for the idiom's intended-empty role units (round 13:
+     * `settleUnitLiveness(...).acceptance`, `@shrkcrft/core`) — set by the plane
+     * that settles the role globs; absent when no role unit is marked. Every
+     * reader folds it beside {@link coverage} through core's `ruleVerdictRecords`,
+     * so an acceptance reaches `accepted` at exit 0 and is never dropped.
+     */
+    readonly unitAcceptance?: IVerdictCoverage;
+    /**
+     * The three roles' glob units settled with their `expectEmpty` markers
+     * (round 13, lane G: `settleGlobLists` over `sourceLivenessRequest`, lists
+     * `declared.files` / `provided.files` / `consumed.files`) — what an idiom's
+     * rule emptiness is decided from (`settleRuleEmptiness`). Absent when no role
+     * marks a unit.
+     */
+    readonly liveness?: ISettledUnitLiveness;
+}
+//# sourceMappingURL=i-registration-roles.d.ts.map

package/dist/wiring/i-registration-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-registration-roles.d.ts","sourceRoot":"","sources":["../../src/wiring/i-registration-roles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,kBAAkB;IACjC,+FAA+F;IAC/F,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,yFAAyF;IACzF,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,GAAG,UAAU,GAAG,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAC7F;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC;CAC1C"}

package/dist/wiring/i-registration-roles.js

@@ -0,0 +1 @@
+export {};

package/dist/wiring/measure-idiom-role-coverage.d.ts

@@ -0,0 +1,12 @@
+import type { IRegistrationIdiom } from '@shrkcrft/core';
+import type { IIdiomRoleCoverage } from './i-idiom-role-coverage.js';
+/**
+ * Every idiom's role coverage for the registration-graph queries (round 13,
+ * P4), from THE role authority `measureRegistrationRoles` — never re-derived
+ * from the graph's token union, which is how `wiring unprovided` printed a ✓
+ * over an idiom whose declared role matched no file while `gates check` said
+ * NOT VERIFIED over the same tree. `excludeDirs` must be the scan scope the
+ * graph was built with (`planeScanExcludeDirs`).
+ */
+export declare function measureIdiomRoleCoverage(cwd: string, idioms: readonly IRegistrationIdiom[], excludeDirs?: readonly string[]): IIdiomRoleCoverage[];
+//# sourceMappingURL=measure-idiom-role-coverage.d.ts.map

package/dist/wiring/measure-idiom-role-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure-idiom-role-coverage.d.ts","sourceRoot":"","sources":["../../src/wiring/measure-idiom-role-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGrE;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,kBAAkB,EAAE,EACrC,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,kBAAkB,EAAE,CAUtB"}

package/dist/wiring/measure-idiom-role-coverage.js

@@ -0,0 +1,20 @@
+import { measureRegistrationRoles } from "./measure-registration-roles.js";
+/**
+ * Every idiom's role coverage for the registration-graph queries (round 13,
+ * P4), from THE role authority `measureRegistrationRoles` — never re-derived
+ * from the graph's token union, which is how `wiring unprovided` printed a ✓
+ * over an idiom whose declared role matched no file while `gates check` said
+ * NOT VERIFIED over the same tree. `excludeDirs` must be the scan scope the
+ * graph was built with (`planeScanExcludeDirs`).
+ */
+export function measureIdiomRoleCoverage(cwd, idioms, excludeDirs = []) {
+    return idioms.map((idiom) => {
+        const roles = measureRegistrationRoles(cwd, idiom, excludeDirs);
+        return {
+            idiom: idiom.name,
+            coverage: roles.coverage,
+            ...(roles.unitAcceptance ? { unitAcceptance: roles.unitAcceptance } : {}),
+            readGap: [roles.declared, roles.provided, roles.consumed].some((r) => r.unread.length > 0),
+        };
+    });
+}

package/dist/wiring/measure-registration-roles.d.ts

@@ -0,0 +1,25 @@
+import { type IRegistrationIdiom } from '@shrkcrft/core';
+import type { IRegistrationRoles } from './i-registration-roles.js';
+/**
+ * Measure every role of one registration idiom with `inspectSource`, the
+ * primitive every plane's coverage adapter uses.
+ *
+ * This is the ONE authority for "is this idiom empty?" and "which role examined
+ * nothing?". `gates check` (`runRegistrationPlane`), `gates coverage`
+ * (`matchRegistration`) and — round 13 (P4) — the registration-graph queries
+ * (`wiring unprovided | orphans`, finish's unprovided sub-gate, MCP
+ * `get_wiring_graph`, through `measureIdiomRoleCoverage`) all call it, so they
+ * cannot drift apart on either question. That is how a `failOnEmpty` idiom used
+ * to FAIL in one verb and pass with a ✓ in the other — and how `wiring
+ * unprovided` printed a ✓ over a declared role that matched no file. (It moved
+ * here from the CLI's gates, which re-export it: the MCP server cannot import
+ * the CLI.)
+ *
+ * A role whose globs matched a file the reader did not read (over the read
+ * cap) is neither "0 files" nor "0 tokens": it matched something it could not
+ * examine. The idiom's coverage is then the file record (`readScopeCoverage`,
+ * the one fold every plane uses), and the idiom is never `empty`, so a
+ * failOnEmpty idiom settles PARTIAL (2), not FAILED (1).
+ */
+export declare function measureRegistrationRoles(cwd: string, idiom: IRegistrationIdiom, excludeDirs?: readonly string[]): IRegistrationRoles;
+//# sourceMappingURL=measure-registration-roles.d.ts.map

package/dist/wiring/measure-registration-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure-registration-roles.d.ts","sourceRoot":"","sources":["../../src/wiring/measure-registration-roles.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kBAAkB,EAGxB,MAAM,gBAAgB,CAAC;AAOxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,kBAAkB,EACzB,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,kBAAkB,CAuFpB"}

package/dist/wiring/measure-registration-roles.js

@@ -0,0 +1,124 @@
+import { resolveSourceGlobs, UnitLivenessState, } from '@shrkcrft/core';
+import { inspectSource } from "../extract/inspect-source.js";
+import { sourceLivenessRequest } from "../extract/source-liveness-request.js";
+import { settleGlobLists } from "../util/settle-glob-lists.js";
+import { readScopeCoverage, readScopeOfLists } from "../util/read-scope-coverage.js";
+import { readMatchingFiles } from "../util/walk-files.js";
+/**
+ * Measure every role of one registration idiom with `inspectSource`, the
+ * primitive every plane's coverage adapter uses.
+ *
+ * This is the ONE authority for "is this idiom empty?" and "which role examined
+ * nothing?". `gates check` (`runRegistrationPlane`), `gates coverage`
+ * (`matchRegistration`) and — round 13 (P4) — the registration-graph queries
+ * (`wiring unprovided | orphans`, finish's unprovided sub-gate, MCP
+ * `get_wiring_graph`, through `measureIdiomRoleCoverage`) all call it, so they
+ * cannot drift apart on either question. That is how a `failOnEmpty` idiom used
+ * to FAIL in one verb and pass with a ✓ in the other — and how `wiring
+ * unprovided` printed a ✓ over a declared role that matched no file. (It moved
+ * here from the CLI's gates, which re-export it: the MCP server cannot import
+ * the CLI.)
+ *
+ * A role whose globs matched a file the reader did not read (over the read
+ * cap) is neither "0 files" nor "0 tokens": it matched something it could not
+ * examine. The idiom's coverage is then the file record (`readScopeCoverage`,
+ * the one fold every plane uses), and the idiom is never `empty`, so a
+ * failOnEmpty idiom settles PARTIAL (2), not FAILED (1).
+ */
+export function measureRegistrationRoles(cwd, idiom, excludeDirs = []) {
+    const declared = inspectSource(cwd, idiom.declared, excludeDirs);
+    const provided = inspectSource(cwd, idiom.provided, excludeDirs);
+    const consumed = inspectSource(cwd, idiom.consumed, excludeDirs);
+    const roles = [
+        ['declared', declared],
+        ['provided', provided],
+        ['consumed', consumed],
+    ];
+    // Round 13 (lane G): the roles' globs settled with their `expectEmpty`
+    // markers — THE per-source request `gates coverage` builds too
+    // (`sourceLivenessRequest`, labels `declared` / `provided` / `consumed`). Only
+    // an idiom that marks a unit pays for it: without a marker there is nothing
+    // intended-empty and nothing to accept.
+    const marked = [idiom.declared, idiom.provided, idiom.consumed].some((s) => (s.expectEmptyUnits?.length ?? 0) > 0);
+    const liveness = marked
+        ? settleGlobLists(sourceLivenessRequest(cwd, [
+            { label: 'declared', source: idiom.declared },
+            { label: 'provided', source: idiom.provided },
+            { label: 'consumed', source: idiom.consumed },
+        ], excludeDirs, idiom.name))
+        : undefined;
+    const unexamined = [];
+    // A role whose globs matched no file BECAUSE every inclusion glob asserts its
+    // target does not exist yet examined nothing on purpose: it is accepted
+    // (settle record B, `unitAcceptance`), never "PARTIAL — consumed (0 files)".
+    const accepted = [];
+    const roleErrors = {};
+    for (const [role, insp] of roles) {
+        if (insp.error !== undefined) {
+            roleErrors[role] = insp.error;
+            unexamined.push(`${role} (could not run: ${insp.error})`);
+        }
+        else if (insp.filesScanned === 0 && insp.unread.length === 0) {
+            if (liveness !== undefined && roleIntendedEmpty(liveness, role))
+                accepted.push(role);
+            else
+                unexamined.push(`${role} (0 files)`);
+        }
+        else if (role === 'declared' && insp.ids.length === 0 && insp.unread.length === 0) {
+            // The primary selector read files and extracted nothing, which is the
+            // plane's "matched nothing". Provided/consumed may legitimately be empty
+            // over live files (see IRegistrationRoles.unexamined).
+            unexamined.push(`${role} (0 tokens)`);
+        }
+    }
+    const firstError = roles.find(([, insp]) => insp.error !== undefined);
+    // Only when some role left a file unread is the idiom's whole read scope
+    // measured, in ONE positive walk over the union of its role globs, then
+    // selected PER ROLE LIST (`readScopeOfLists`: a file two roles share is
+    // counted once, and one role's `!x` never hides another role's file). The
+    // common case pays nothing extra.
+    const scope = roles.some(([, insp]) => insp.unread.length > 0)
+        ? readScopeOfLists(readMatchingFiles(cwd, unionGlobs(idiom), new Set(excludeDirs)), [idiom.declared, idiom.provided, idiom.consumed].map((role) => resolveSourceGlobs(role)))
+        : undefined;
+    // The roles JUDGED are the ones not accepted as intended-empty; an accepted
+    // role rides on the acceptance (record B), never as an examined unit.
+    const judged = roles.length - accepted.length;
+    const roleCoverage = {
+        unit: 'roles',
+        expected: judged,
+        examined: judged - unexamined.length,
+        ...(unexamined.length > 0
+            ? { unexamined, reason: 'matched nothing or could not run, so the role selector is probably stale' }
+            : {}),
+    };
+    // Every role intended-empty: the acceptance IS the idiom's coverage — an
+    // unsuppressed `{ expected: 0 }` would settle 2 over an accepted idiom.
+    const primary = judged === 0 && liveness?.acceptance !== undefined ? liveness.acceptance : roleCoverage;
+    return {
+        declared,
+        provided,
+        consumed,
+        empty: declared.ids.length === 0 && declared.unread.length === 0,
+        unexamined,
+        ...(firstError ? { error: `${firstError[0]}: ${firstError[1].error}` } : {}),
+        roleErrors,
+        coverage: readScopeCoverage(primary, scope),
+        ...(liveness?.acceptance !== undefined ? { unitAcceptance: liveness.acceptance } : {}),
+        ...(liveness !== undefined ? { liveness } : {}),
+    };
+}
+/** Whether every inclusion glob of a role's `files` is intended-empty (and the role has one). */
+function roleIntendedEmpty(liveness, role) {
+    const inclusion = liveness.units.filter((u) => u.list === `${role}.files` && !u.unit.startsWith('!'));
+    return inclusion.length > 0 && inclusion.every((u) => u.state === UnitLivenessState.IntendedEmpty);
+}
+/** Every glob any role of the idiom walks, deduped. */
+function unionGlobs(idiom) {
+    return [
+        ...new Set([
+            ...resolveSourceGlobs(idiom.declared),
+            ...resolveSourceGlobs(idiom.provided),
+            ...resolveSourceGlobs(idiom.consumed),
+        ]),
+    ];
+}

package/dist/wiring/plan-wiring-fix.d.ts

@@ -12,7 +12,14 @@ export type WiringFixRefusal =
 /** The array literal could not be located in the sink file. */
  | 'array-not-found'
 /** The token is a quoted string in the sink; the declared side is a symbol (or vice versa). */
- | 'token-shape-mismatch';
+ | 'token-shape-mismatch'
+/**
+ * The sink IMPORTS its array members, so appending to the array alone would
+ * leave an unbound reference — a green gate over a file that does not
+ * compile. Raised whenever the needed import cannot be derived with
+ * certainty.
+ */
+ | 'needs-import';
 /** One planned edit: append `token` into the anchor array of `file`. */
 export interface IWiringFixEdit {
     readonly ruleId: string;
@@ -25,6 +32,14 @@ export interface IWiringFixEdit {
     readonly insert: string;
     /** The full new file contents, ready to write. */
     readonly nextContent: string;
+    /**
+     * The import statement added alongside the array append, when the sink
+     * imports its members and the specifier was derivable. Absent when the token
+     * was already bound in the sink file.
+     */
+    readonly importInsert?: string;
+    /** 1-based line the import statement lands on. */
+    readonly importLine?: number;
 }
 /** A violation the planner deliberately did not touch. */
 export interface IWiringFixSkip {

package/dist/wiring/plan-wiring-fix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan-wiring-fix.d.ts","sourceRoot":"","sources":["../../src/wiring/plan-wiring-fix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,gBAAgB,CAAC;AAGjE,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGhF,eAAO,MAAM,iBAAiB,EAAG,0BAAmC,CAAC;AAErE,uDAAuD;AACvD,MAAM,MAAM,gBAAgB;AAC1B,mEAAmE;AACjE,gBAAgB;AAClB,iEAAiE;GAC/D,mBAAmB;AACrB,wDAAwD;GACtD,qBAAqB;AACvB,+DAA+D;GAC7D,iBAAiB;AACnB,+FAA+F;GAC7F,sBAAsB,CAAC;AAE3B,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uFAAuF;IACvF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,iBAAiB,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;CAC7C;AAED,2CAA2C;AAC3C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAiBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,SAAS,gBAAgB,EAAE,EACvC,KAAK,EAAE,SAAS,cAAc,EAAE,GAC/B,cAAc,CAqHhB"}
+{"version":3,"file":"plan-wiring-fix.d.ts","sourceRoot":"","sources":["../../src/wiring/plan-wiring-fix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,gBAAgB,CAAC;AAIjE,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAWhF,eAAO,MAAM,iBAAiB,EAAG,0BAAmC,CAAC;AAErE,uDAAuD;AACvD,MAAM,MAAM,gBAAgB;AAC1B,mEAAmE;AACjE,gBAAgB;AAClB,iEAAiE;GAC/D,mBAAmB;AACrB,wDAAwD;GACtD,qBAAqB;AACvB,+DAA+D;GAC7D,iBAAiB;AACnB,+FAA+F;GAC7F,sBAAsB;AACxB;;;;;GAKG;GACD,cAAc,CAAC;AAEnB,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uFAAuF;IACvF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,kDAAkD;IAClD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,iBAAiB,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;CAC7C;AAED,2CAA2C;AAC3C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAuKD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,SAAS,gBAAgB,EAAE,EACvC,KAAK,EAAE,SAAS,cAAc,EAAE,GAC/B,cAAc,CA2KhB"}