@shrkcrft/boundaries 0.1.0-alpha.28 → 0.1.0-alpha.30

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

@@ -11,6 +11,13 @@ export interface IWiringSideExplain {
     readonly filesScanned: number;
     /** Misconfiguration (bad regex / no capture group / bad source), if any. */
     readonly error?: string;
+    /**
+     * Named extractor this side resolved from, when it used one. Surfaced so an
+     * author reading an explain can tell a SHARED selector from a local copy of
+     * it — the two look identical in the extracted ids, and only one of them is
+     * guaranteed to stay in step with the other planes.
+     */
+    readonly viaExtractor?: string;
 }
 /**
  * The full intermediate output of evaluating ONE wiring rule against the live
@@ -48,14 +55,5 @@ export interface IExplainWiringOptions {
     /** Project-relative directories to prune from the walk. */
     readonly excludeDirs?: readonly string[];
 }
-/**
- * Dry-run a single wiring rule against the live tree and return what each side
- * extracted (declared set, registered set, the set-difference, the verdict) —
- * WITHOUT writing config. Powers `wiring explain <ruleId>`, `wiring test
- * <candidate>`, `gates explain <id>`, and `check wiring --explain <ruleId>`: the
- * author can SEE the cross-file set-difference the gate computes before
- * committing a rule. The diff/verdict reuse {@link evaluateWiring} so they match
- * the gate exactly (incl. `groupBy` membership). Never throws.
- */
 export declare function explainWiring(projectRoot: string, rule: IWiringRule, options?: IExplainWiringOptions): IWiringExplain;
 //# sourceMappingURL=explain-wiring.d.ts.map

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":"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;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;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;AAiCD,wBAAgB,aAAa,CAC3B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,WAAW,EACjB,OAAO,GAAE,qBAA0B,GAClC,cAAc,CA2EhB"}

package/dist/wiring/explain-wiring.js

@@ -14,6 +14,22 @@ function sortSites(sites) {
  * committing a rule. The diff/verdict reuse {@link evaluateWiring} so they match
  * the gate exactly (incl. `groupBy` membership). Never throws.
  */
+/**
+ * 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, rule, options = {}) {
     const sourceSide = wiringSourceSide(rule);
     // For a chain, the reported "registered" side is the LAST hop (the far end).
@@ -63,12 +79,14 @@ 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 } : {}),
         },
         registered: {
             sites: sortSites(registeredSites),
             distinctCount: ruleResult?.registeredCount ?? 0,
             filesScanned: registeredFiles.size,
             ...(registeredError ? { error: registeredError } : {}),
+            ...(registeredExtractorRef(rule) ? { viaExtractor: registeredExtractorRef(rule) } : {}),
         },
         declaredNotRegistered: byDirection('declared-missing'),
         registeredNotDeclared: byDirection('registered-missing'),

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

@@ -0,0 +1,75 @@
+import type { IWiringRule } from '@shrkcrft/core';
+import { type IWiringViolation } from './evaluate-wiring.js';
+export declare const WIRING_FIX_SCHEMA: "sharkcraft.wiring-fix/v1";
+/** Why a violation could not be fixed mechanically. */
+export type WiringFixRefusal = 
+/** More than one registered sink — which array should it go in? */
+'ambiguous-sink'
+/** The sink is not an array literal the engine can append to. */
+ | 'sink-not-an-array'
+/** The sink glob resolves to several files, or none. */
+ | 'ambiguous-sink-file'
+/** 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'
+/**
+ * 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;
+    readonly token: string;
+    /** Project-relative sink file the edit lands in. */
+    readonly file: string;
+    /** 1-based line of the array's closing bracket, where the token is inserted before. */
+    readonly line: number;
+    /** The exact text inserted, including indentation and trailing comma. */
+    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 {
+    readonly ruleId: string;
+    readonly token: string;
+    readonly reason: WiringFixRefusal;
+    readonly detail: string;
+}
+export interface IWiringFixPlan {
+    readonly schema: typeof WIRING_FIX_SCHEMA;
+    readonly edits: readonly IWiringFixEdit[];
+    readonly skipped: readonly IWiringFixSkip[];
+}
+/** A file the planner may read/rewrite. */
+export interface IWiringFixFile {
+    readonly path: string;
+    readonly content: string;
+}
+/**
+ * Plan the mechanically-unambiguous fixes for `declared-but-not-registered`
+ * violations.
+ *
+ * The bar is deliberately high, because a wrong autofix in a gate is worse than
+ * no autofix: the tool would be writing the very thing it is supposed to
+ * verify. An edit is planned ONLY when there is exactly one registered sink,
+ * that sink is an `array-members` source, its glob resolves to exactly one
+ * file, and the anchor array is found exactly once in it. Every other shape is
+ * reported as skipped WITH the reason — never guessed at.
+ *
+ * Pure: the caller supplies file contents and performs any writes.
+ */
+export declare function planWiringFix(rule: IWiringRule, violations: readonly IWiringViolation[], files: readonly IWiringFixFile[]): IWiringFixPlan;
+//# sourceMappingURL=plan-wiring-fix.d.ts.map

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

@@ -0,0 +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;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"}

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

@@ -0,0 +1,302 @@
+import { matchesAny } 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`. */
+function indentOf(content, index) {
+    const lineStart = content.lastIndexOf('\n', index - 1) + 1;
+    const m = /^[ \t]*/.exec(content.slice(lineStart, index));
+    return m ? m[0] : '  ';
+}
+function lineOf(content, index) {
+    let line = 1;
+    for (let i = 0; i < index && i < content.length; i += 1) {
+        if (content[i] === '\n')
+            line += 1;
+    }
+    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.
+ *
+ * The bar is deliberately high, because a wrong autofix in a gate is worse than
+ * no autofix: the tool would be writing the very thing it is supposed to
+ * verify. An edit is planned ONLY when there is exactly one registered sink,
+ * that sink is an `array-members` source, its glob resolves to exactly one
+ * file, and the anchor array is found exactly once in it. Every other shape is
+ * reported as skipped WITH the reason — never guessed at.
+ *
+ * Pure: the caller supplies file contents and performs any writes.
+ */
+export function planWiringFix(rule, violations, files) {
+    const edits = [];
+    const skipped = [];
+    const declaredMissing = violations.filter((v) => v.ruleId === rule.id && v.direction === 'declared-missing');
+    if (declaredMissing.length === 0)
+        return { schema: WIRING_FIX_SCHEMA, edits, skipped };
+    const refuseAll = (reason, detail) => ({
+        schema: WIRING_FIX_SCHEMA,
+        edits: [],
+        skipped: declaredMissing.map((v) => ({ ruleId: rule.id, token: v.token, reason, detail })),
+    });
+    // A chain rule has no single "the sink"; refuse rather than pick one.
+    const sinks = rule.chain
+        ? []
+        : registeredSources(rule.registered);
+    if (sinks.length !== 1) {
+        return refuseAll('ambiguous-sink', sinks.length === 0
+            ? 'rule has no single registered sink (chain rules are never auto-fixed)'
+            : `rule has ${sinks.length} registered sinks — which one should the token join?`);
+    }
+    const sink = sinks[0];
+    if (resolveExtractorKind(sink) !== 'array-members') {
+        return refuseAll('sink-not-an-array', `sink uses extract "${resolveExtractorKind(sink) ?? 'unknown'}" — only an array literal can be appended to`);
+    }
+    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 ?? []));
+    if (sinkFiles.length !== 1) {
+        return refuseAll('ambiguous-sink-file', `sink glob matched ${sinkFiles.length} files — the insertion point must be unique`);
+    }
+    const target = sinkFiles[0];
+    // Locate the anchor array. More than one occurrence is ambiguous.
+    const head = new RegExp(`(?<![\\w$])${escapeRegex(anchor)}\\s*(?::[^=\\n]*)?[:=]\\s*(?:[A-Za-z_$][\\w$.]*\\s*\\(\\s*)?\\[`, 'g');
+    const opens = [];
+    let m;
+    while ((m = head.exec(target.content)) !== null)
+        opens.push(m.index + m[0].length - 1);
+    if (opens.length !== 1) {
+        return refuseAll('array-not-found', opens.length === 0
+            ? `array \`${anchor}\` not found in ${target.path}`
+            : `array \`${anchor}\` appears ${opens.length} times in ${target.path}`);
+    }
+    const openIndex = opens[0];
+    const { elements, end } = scanBalanced(target.content, openIndex);
+    // Match the shape of what is already in the array: bare identifiers vs
+    // quoted strings. Inserting the wrong shape would compile-fail or silently
+    // not match on the next run.
+    const firstEl = elements[0]?.text ?? '';
+    const quoted = firstEl.startsWith("'") || firstEl.startsWith('"');
+    const quoteChar = firstEl.startsWith('"') ? '"' : "'";
+    // Build all edits against one evolving buffer so multiple tokens accumulate.
+    let content = target.content;
+    let insertAt = end;
+    for (const v of declaredMissing) {
+        // Re-locate the closing bracket after each insertion.
+        const reHead = new RegExp(head.source, 'g');
+        const mm = reHead.exec(content);
+        if (!mm) {
+            skipped.push({
+                ruleId: rule.id,
+                token: v.token,
+                reason: 'array-not-found',
+                detail: `array \`${anchor}\` vanished mid-plan in ${target.path}`,
+            });
+            continue;
+        }
+        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) : '  ';
+        const multiline = content.slice(open, insertAt).includes('\n');
+        const rendered = quoted ? `${quoteChar}${v.token}${quoteChar}` : v.token;
+        // Insert after the last non-whitespace character, and KEEP the whitespace
+        // run that precedes the closing bracket — trimming it would drag `]` up
+        // onto the last element's line and reformat code the user did not ask us
+        // to touch.
+        const beforeInsert = content.slice(0, insertAt).replace(/\s+$/, '');
+        const cut = beforeInsert.length;
+        const tail = content.slice(cut, insertAt);
+        const needsComma = scan.elements.length > 0 && !beforeInsert.endsWith(',');
+        const insert = multiline
+            ? `${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: 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,4 @@
-import type { IRegistrationIdiom } from '@shrkcrft/core';
+import { type IRegistrationIdiom } from '@shrkcrft/core';
 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. */

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,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { statSync } from 'node:fs';
 import * as nodePath from 'node:path';
+import { resolveSourceGlobs } from '@shrkcrft/core';
 import { matchesAny } from "../scan/glob.js";
 import { readMatchingFiles, walkMatching } from "../util/walk-files.js";
 import { collectSourceSites } from "./evaluate-wiring.js";
@@ -11,7 +12,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),
+        ])),
     ];
 }
 /**
@@ -28,7 +33,7 @@ export function buildRegistrationGraph(projectRoot, idioms, options = {}) {
         path,
         content,
     }));
-    const filesFor = (source) => entries.filter((f) => matchesAny(f.path, source.files));
+    const filesFor = (source) => entries.filter((f) => matchesAny(f.path, resolveSourceGlobs(source)));
     const declared = new Map();
     const provided = new Map();
     const consumed = new Map();
@@ -96,7 +101,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) => matchesAny(f.path, resolveSourceGlobs(idiom.provided)));
         for (const s of collectSourceSites(idiom.provided, files).sites)
             tokens.add(s.token);
     }

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

@@ -1,4 +1,4 @@
-import type { IRegistryDeclaration } from '@shrkcrft/core';
+import { type IRegistryDeclaration } from '@shrkcrft/core';
 export declare const REGISTRY_SCHEMA: "sharkcraft.registry-inventory/v1";
 /** Where an id was found (project-relative path + 1-based line). */
 export interface IRegistrySite {

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;AAK/E,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,CAkDpB;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,3 +1,4 @@
+import { resolveSourceGlobs } from '@shrkcrft/core';
 import { matchesAny } from "../scan/glob.js";
 import { readMatchingFiles } from "../util/walk-files.js";
 import { collectSourceSites } from "./evaluate-wiring.js";
@@ -12,18 +13,21 @@ 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 diagnostics = [];
-    const sourceFiles = entries.filter((f) => matchesAny(f.path, decl.source.files));
+    const sourceFiles = entries.filter((f) => matchesAny(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) => matchesAny(f.path, resolveSourceGlobs(decl.consumer)));
         const consumed = collectSourceSites(decl.consumer, consumerFiles);
         if (consumed.error)
             diagnostics.push(`registry "${decl.name}" consumer: ${consumed.error}`);

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. */

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,EAAsB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAItE,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,CAqCf"}

package/dist/wiring/scan-wiring-files.js

@@ -1,5 +1,7 @@
+import { resolveSourceGlobs } from '@shrkcrft/core';
 import { matchesAny } from "../scan/glob.js";
 import { readMatchingFiles } from "../util/walk-files.js";
+import { loadTsconfigPaths } from "../scan/tsconfig-aliases.js";
 import { evaluateWiring, wiringGlobsOf, } from "./evaluate-wiring.js";
 /** All file globs a rule references: every side / every hop. */
 function ruleGlobs(rule) {
@@ -38,5 +40,7 @@ export function runWiring(projectRoot, rules, options = {}) {
     const allGlobs = [...new Set(selected.flatMap(ruleGlobs))];
     const cache = readMatchingFiles(projectRoot, allGlobs, new Set(options.excludeDirs ?? []));
     const entries = [...cache.entries()].map(([path, content]) => ({ path, content }));
-    return evaluateWiring(selected, (source) => entries.filter((f) => matchesAny(f.path, source.files)));
+    // The tsconfig paths let an `import-edges` source resolve alias specifiers the
+    // way the compiler does — the same map `check boundaries` resolves with.
+    return evaluateWiring(selected, (source) => entries.filter((f) => matchesAny(f.path, resolveSourceGlobs(source))), { tsconfigPaths: loadTsconfigPaths(projectRoot) });
 }