ts-axi 0.1.5 → 0.1.7

package/README.md

@@ -41,7 +41,7 @@ Read-only: no lint, no refactor, no rename.
 
 Early, but already used in real reviews. What the numbers say so far:
 
-- **Correctness on the test corpus.** 152 unit and command tests over five synthetic fixtures (a TS project with an interface and three implementations, an Nx-style workspace with `tsconfig.base.json` paths and a pnpm workspace, a script-style JavaScript tree, a CommonJS package and an ESM package without tsconfig), plus 39 integration tests that run the built binary against a vendored Astro + React one-pager (`test/integration/sample`: barrel re-exports, JSX islands, custom hooks, a JS consumer of a TS export, a `.ts-axi.json` test glob). They pin exact line numbers, reference counts, test counts, change classes and the interface split.
+- **Correctness on the test corpus.** 163 unit and command tests over five synthetic fixtures (a TS project with an interface and three implementations, an Nx-style workspace with `tsconfig.base.json` paths and a pnpm workspace, a script-style JavaScript tree, a CommonJS package and an ESM package without tsconfig), plus 39 integration tests that run the built binary against a vendored Astro + React one-pager (`test/integration/sample`: barrel re-exports, JSX islands, custom hooks, a JS consumer of a TS export, a `.ts-axi.json` test glob). They pin exact line numbers, reference counts, test counts, change classes and the interface split.
 - **A real monorepo** (Nx, 142 projects, ~5.4k source files after gitignore): `refs` on a service method finds its two callers in *another* project in 3-5 s without any flag; `impact` on a 7-file commit reports 15 changes with cross-project references in ~5 s; `callers` on a method that implements an interface shared by seven classes reports the 1 direct call plus the spec calls, where the raw compiler API returned 8 unrelated implementations. Before the workspace scope, the same `impact` ran out of memory.
 - **Against grep, in characters an agent has to read** (same monorepo, measured by a reviewer session): `callers` 720 vs ~3.5k for the two greps a reviewer needs - and grep still leaves the interface ambiguity to the human; `impact` on a commit 4.7k vs ~7.3k for per-symbol greps plus the `git show --stat` needed to learn the symbol list. `def` on a very common name was *worse* than grep until nested git worktrees were excluded (96 matches, 92 of them copies); it is 4 now.
 
@@ -175,7 +175,7 @@ decls[4]{line,kind,name,exported,signature}:
   17,function,cartBadge,true,directive cartBadge()
 ```
 
-An edit inside `CartCtrl` is reported by `impact` as `CartCtrl body`, not as a file-level change. Names registered by a string have no identifier the checker can follow; `refs` says so and offers `--grep`.
+An edit inside `CartCtrl` is reported by `impact` as `CartCtrl body`, not as a file-level change. Names registered by a string have no identifier the checker can follow; `refs` says so and offers `--grep`. ui-router and ngRoute states are Declarations of kind `state` (`states.cart`, with callbacks as `states.cart.resolve.items`), so an edit inside a `resolve` names that callback; state objects in exported arrays (`` module.exports = [{ name: `${base}.init`, url, resolve }] ``) count too, their template-literal names filled from same-file consts. Directives, components, their `scope`/`bindings` keys, controllers and filters also get `templates: <n> usages in <m> files` (kebab-case elements and attributes, `ng-controller`, `| filter` in `.html`/`.htm`/`.ejs`/`.hbs`/`.njk`/`.pug`), a `templates` column in `impact`, and a changed template that uses a changed directive or binding is listed under `template_changes` instead of `skipped`.
 
 ## Monorepos
 
@@ -219,7 +219,7 @@ One dependency: the `typescript` compiler API (ADR in `docs/adr/0001-typescript-
 - `refs`, `callers` and `impact` build a `LanguageService` over the nearest `tsconfig.json` (or an implicit project of every source file when none exists, with a warning; in a monorepo or an implicit project of more than 3000 files, over the importer subgraph described above) and ask it for references and call hierarchy. Symbol identity comes from the checker, so `user.save` resolves to `User.save` through imports and re-exports.
 - `impact` reads the "before" version of touched files with `git show` and compares signatures to classify each change (`added`, `removed`, `signature`, `body`, `type`, `modified`). Uses it cannot follow (access through `any`, dynamic string keys) are reported as `blind_spots`, never silently dropped.
 - Module resolution keeps TypeScript's rules with two substitutions so References reach implementations: a `.d.ts` that has a JavaScript twin in the Project (`index.d.ts` beside `index.js`) resolves to the twin, and a CommonJS shim whose only statement is `module.exports = require('./x')` resolves to `./x`, so `require('..')` reaches the real function. A `.d.ts` twin that still ends up in the program is queried too and its References merged.
-- Script-style JavaScript (AngularJS registrations, Meteor methods and helpers, `module.exports` objects, prototype methods, IIFE helpers) gets nested declarations with qualified names, so `outline` lists them and `impact` names the function an edit touches instead of a file-level change.
+- Script-style JavaScript (AngularJS registrations and ui-router states, Meteor methods and helpers, `module.exports` objects, prototype methods, IIFE helpers) gets nested declarations with qualified names, so `outline` lists them and `impact` names the function an edit touches instead of a file-level change.
 - Type errors in the analysed project never block anything; they are reported as a `diagnostics` count.
 
 Every semantic command starts cold and prints `elapsed_ms`.

package/dist/src/commands/def.js

@@ -5,7 +5,7 @@ import { isFunctionLike, kindFromScriptElement, parseTarget } from "../symbols.j
 import { BODY_LINES, declarationAt, filterSuffix, MATCH_ROWS, matchRows, narrowHints, numberedLines, open, positionStartDir, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, readFilters, } from "./common.js";
 export const DEF_HELP = `usage: ts-axi def <name | Class.member | path:line[:col]> [flags]
 flags[7]:
-  --kind <function|class|method|property|variable|interface|type|enum|enum-member|namespace>, --in <dir|glob> (repeatable; restrict to files), --exported, --fuzzy (substring, case-insensitive), --full (whole body; default first ${BODY_LINES} lines), -P <tsconfig>, --json
+  --kind <function|class|method|property|variable|interface|type|enum|enum-member|namespace|state>, --in <dir|glob> (repeatable; restrict to files), --exported, --fuzzy (substring, case-insensitive), --full (whole body; default first ${BODY_LINES} lines), -P <tsconfig>, --json
 output:
   1 match = file, line, kind, exported, signature + body fenced with file line numbers
   several = matches[n]{file,line,kind,exported,signature} (at most ${MATCH_ROWS}; matches_total + truncated past that) + the narrowing forms (--in, --kind, Class.member, --exported) with how many each keeps

package/dist/src/commands/impact.js

@@ -11,6 +11,7 @@ import { block, helpBlock, out } from "../render.js";
 import { isTestFile } from "../settings.js";
 import { isFunctionLike } from "../symbols.js";
 import { IMPACT_HOPS, scopeFields, scopeHelp, semanticFor } from "../scope.js";
+import { isTemplatePath, loadTemplates, templateTarget, templateUsages, usagesIn } from "../templates.js";
 import { walkFiles } from "../walk.js";
 import { contextOf, lineOf, open, projectFields } from "./common.js";
 const DEFAULT_LIMIT = 50;
@@ -28,12 +29,14 @@ flags[7]:
 output:
   base, head, changes (count), changed[n]{symbol,kind,change,exported,at,refs_total,refs_outside,via,files,tests}
   change = signature | removed | type | added | body | modified (before unavailable) - riskiest first
-  textual = column added only when an untyped (JavaScript; implicit project) Symbol has more whole-word matches outside the change set than refs_outside - those are uses the checker cannot resolve; - for typed rows; such a Change is never local_only
+  textual = column added only when an untyped (JavaScript; implicit project) Symbol has more whole-word matches outside the change set than refs_outside - those are uses the checker cannot resolve (declaring file only for a non-exported local); - for typed rows; such a Change is never local_only
   refs_* / files / tests count direct References only; via = References outside the change set that reach the Symbol through an interface or base member it implements (or name an override of it) - they MAY call it
   refs[n]{symbol,file,line,context} = References outside the change set; truncated + refs_shown + refs_outside_total when cut
   notes[n]{symbol,note} = a signature change of a member that implements an interface or base member (the contract may break)
   local_only = Changes with no Reference outside the change set; file_level[n]{file,lines} = changed lines outside any Declaration
   blind_spots[n]{symbol,file,line,reason} = uses the checker cannot follow (any; string keys; unresolved export *)
+  templates = column added only when a changed Symbol is one templates name (directive, component, binding, controller, filter): its usages in .html/.htm/.ejs/.hbs/.njk/.pug files; - for other rows; such a Change is never local_only
+  template_changes[n]{file,symbols} = templates in the diff that use a changed directive, binding, controller or filter - review them with that change
   skipped[n]{file,reason} = files in the diff that were not analysed (.astro, .json, outside the Project)
   tests: 0 on an exported signature or body change = no Test file references it
   scope = in a monorepo without -P the program is the touched files + two levels of importers (scope_partial: true when capped)
@@ -228,8 +231,11 @@ function blindSpots(semantic, names, changeSet) {
 function walkExtra(dir, outFiles) {
     outFiles.push(...walkFiles(dir, { accept: (name) => GREP_EXTRA.some((ext) => name.endsWith(ext)) }).files);
 }
-/** Whole-word matches of `names` in Project files and templates that are not `known` References. */
-export function textualMatches(opened, semantic, names, known, skipLines, changeSet) {
+/**
+ * Whole-word matches of `names` in Project files and templates that are not `known` References;
+ * a name in `localTo` (name → absolute file) is searched in that file only.
+ */
+export function textualMatches(opened, semantic, names, known, skipLines, changeSet, localTo = new Map()) {
     const files = [...semantic.projectFiles];
     const projectSet = new Set(files);
     walkExtra(opened.root, files);
@@ -243,6 +249,8 @@ export function textualMatches(opened, semantic, names, known, skipLines, change
         const declared = new Set(projectSet.has(abs) ? opened.index.declarations(abs).map((d) => d.nameLine) : []);
         const lines = new Set();
         for (const name of names) {
+            if (localTo.has(name) && localTo.get(name) !== abs)
+                continue;
             for (const m of wordMatches(text, name)) {
                 if (known.has(`${rel}:${m.line}`) || skipLines.has(`${rel}:${m.line}`) || declared.has(m.line) || inRanges(changeSet.get(rel), m.line))
                     continue;
@@ -255,15 +263,27 @@ export function textualMatches(opened, semantic, names, known, skipLines, change
     }
     return rows.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
 }
-/** The checker may miss uses: JS declaring file, a string-registered name, or no tsconfig at all. */
+/**
+ * The checker may miss uses: JS declaring file, a string-registered name, or no tsconfig at all.
+ * A state's hooks (`onEnter`, inline `controller`) are called by the router, never by name: no textual count.
+ */
 export function isUntyped(opened, decl, file) {
+    if (decl?.parentName !== undefined && /^(states|routes)\./.test(decl.parentName) && !decl.parentName.endsWith(".resolve"))
+        return false;
     return decl?.nameless === true || opened.index.project.implicit || (file !== undefined && /\.[mc]?jsx?$/.test(file));
 }
-/** Whole-word occurrences of `name` in Project files outside `changeSet`; lines declaring a `name` excluded. */
-export function textualCount(opened, name, changeSet = new Map()) {
+/** A non-exported, non-member, identifier-named Declaration: only its own file can name it. */
+export function isPlainLocal(decl) {
+    return decl !== undefined && !decl.exported && !decl.nameless && decl.parentName === undefined;
+}
+/**
+ * Whole-word occurrences of `name` in Project files outside `changeSet`; lines declaring a `name` excluded.
+ * With `onlyFile` (absolute), that file alone.
+ */
+export function textualCount(opened, name, changeSet = new Map(), onlyFile) {
     let matches = 0;
     let files = 0;
-    for (const abs of opened.index.files) {
+    for (const abs of onlyFile !== undefined ? [onlyFile] : opened.index.files) {
         const text = opened.index.text(abs);
         if (text === undefined || !text.includes(name))
             continue;
@@ -274,14 +294,30 @@ export function textualCount(opened, name, changeSet = new Map()) {
         if (n > 0)
             files++;
     }
-    return { matches, files };
+    return { matches, files, ...(onlyFile !== undefined ? { fileScoped: true } : {}) };
 }
 export function textualLine(count) {
-    return `${count.matches} matches in ${count.files} files`;
+    return count.fileScoped ? `${count.matches} matches in this file` : `${count.matches} matches in ${count.files} files`;
 }
 export function textualHint(command, gap) {
     return `Run \`${command}\` for the ${gap} textual matches the checker cannot resolve (untyped JavaScript)`;
 }
+/** `--grep` rows plus template usages of the templated rows, one per file:line. */
+function withTemplateRows(textRows, rows, files) {
+    const texts = new Map(files.map((f) => [f.rel, f.text]));
+    const seen = new Set(textRows.map((u) => `${u.file}:${u.line}`));
+    const result = [...textRows];
+    for (const row of rows) {
+        for (const u of row.templates ?? []) {
+            const key = `${u.file}:${u.line}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            result.push({ file: u.file, line: u.line, context: contextOf(lineOf(texts.get(u.file), u.line), u.col) });
+        }
+    }
+    return result.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+}
 function siteKey(site) {
     return `${site.item.file}#${site.item.selectionSpan.start}`;
 }
@@ -390,9 +426,13 @@ export async function impactCommand(args, ctx) {
         ...input.missing.map((file) => ({ file, reason: "not in the working tree" })),
     ];
     const analysed = [];
+    // Templates stay skipped unless they use a changed Symbol (then template_changes).
+    const templateInputs = [];
     for (const file of input.files) {
         if (/\.d\.[mc]?ts$/.test(file.path))
             skipped.push({ file: file.path, reason: "declaration file" });
+        else if (isTemplatePath(file.path))
+            templateInputs.push(file);
         else if (!isSourcePath(file.path))
             skipped.push({ file: file.path, reason: "not TS or JS source" });
         else if (file.status !== "deleted" && !projectFiles.has(opened.index.abs(file.path)))
@@ -431,8 +471,14 @@ export async function impactCommand(args, ctx) {
         head: input.head,
         changes: total,
     };
-    const skippedBlock = skipped.length > 0 ? capped("skipped", skipped) : {};
+    const skipTemplates = (used) => {
+        for (const f of templateInputs)
+            if (!used.has(f.path))
+                skipped.push({ file: f.path, reason: "not TS or JS source" });
+    };
     if (declChanges.length === 0) {
+        skipTemplates(new Set());
+        const skippedBlock = skipped.length > 0 ? capped("skipped", skipped) : {};
         const help = total === 0
             ? [arg === undefined && !staged ? "Run `ts-axi impact main...HEAD` to analyse a branch against main" : "Run `ts-axi impact` for uncommitted changes"]
             : ["Changes touch imports or module-level statements only - read those lines directly"];
@@ -495,14 +541,41 @@ export async function impactCommand(args, ctx) {
     for (const row of rows) {
         if (!row.live || !isUntyped(opened, row.live, row.live.file))
             continue;
-        row.textual = textualCount(opened, row.live.name, changeSet);
+        const localTo = isPlainLocal(row.live) ? new Map([[row.live.name, opened.index.abs(row.live.file)]]) : undefined;
+        row.textual = textualCount(opened, row.live.name, changeSet, localTo?.get(row.live.name));
         if (row.textual.matches > 0)
-            row.unresolved = textualMatches(opened, semantic, [row.live.name], known, new Set(), changeSet).length;
+            row.unresolved = textualMatches(opened, semantic, [row.live.name], known, new Set(), changeSet, localTo).length;
     }
+    // Template usages: directives, components, bindings, controllers and filters named in .html and friends.
+    let templateFiles;
+    for (const row of rows) {
+        const decl = row.live ?? row.change.before;
+        const fileDecls = [
+            ...opened.index.declarations(opened.index.abs(row.change.file)),
+            ...declChanges.filter((c) => c.file === row.change.file).flatMap((c) => (c.before ? [c.before] : [])),
+        ];
+        const target = templateTarget(decl, fileDecls);
+        if (!target)
+            continue;
+        templateFiles ??= loadTemplates(opened.root);
+        row.template = target;
+        row.templates = templateUsages(templateFiles, target);
+    }
+    const templateChanges = [];
+    for (const f of templateInputs) {
+        const text = f.afterText ?? f.beforeText;
+        if (typeof text !== "string")
+            continue;
+        const symbols = [...new Set(rows.filter((r) => r.template && usagesIn(text, r.template).length > 0).map((r) => r.symbol))];
+        if (symbols.length > 0)
+            templateChanges.push({ file: f.path, symbols: symbols.join("; ") });
+    }
+    skipTemplates(new Set(templateChanges.map((t) => t.file)));
+    const skippedBlock = skipped.length > 0 ? capped("skipped", skipped) : {};
     // Textual matches the checker did not resolve: such a Change is never local_only.
     const textualGap = (r) => (r.textual && r.textual.matches > r.outside.length ? r.unresolved ?? 0 : 0);
     const shownRefs = (r) => (showVia ? [...r.outside, ...r.via].sort(byPosition) : r.outside);
-    const hasOutside = (r) => r.outside.length > 0 || r.via.length > 0 || textualGap(r) > 0;
+    const hasOutside = (r) => r.outside.length > 0 || r.via.length > 0 || textualGap(r) > 0 || (r.templates?.length ?? 0) > 0;
     const listed = rows
         .filter(hasOutside)
         .sort((a, b) => compareChanges({ change: a.change.change, exported: a.exported, refsOutside: a.outside.length, file: a.change.file, line: (a.live ?? a.change.before).line }, { change: b.change.change, exported: b.exported, refsOutside: b.outside.length, file: b.change.file, line: (b.live ?? b.change.before).line }));
@@ -525,15 +598,27 @@ export async function impactCommand(args, ctx) {
     };
     // --- Blind spots, textual matches, deeper callers ---
     const names = new Map();
+    // A name is file-scoped only when every changed Declaration carrying it is a plain local of one file.
+    const localTo = new Map();
+    const wide = new Set();
     for (const r of rows) {
-        const name = (r.change.after ?? r.change.before).name;
+        const decl = r.change.after ?? r.change.before;
+        const name = decl.name;
         if (!names.has(name))
             names.set(name, r.symbol);
+        const abs = opened.index.abs(decl.file);
+        if (!isPlainLocal(decl) || (localTo.has(name) && localTo.get(name) !== abs))
+            wide.add(name);
+        else
+            localTo.set(name, abs);
     }
+    for (const name of wide)
+        localTo.delete(name);
     const spots = blindSpots(semantic, names, changeSet);
-    const unresolved = grep
-        ? textualMatches(opened, semantic, [...names.keys()], known, new Set(spots.map((s) => `${s.file}:${s.line}`)), changeSet)
+    const textRows = grep
+        ? textualMatches(opened, semantic, [...names.keys()], known, new Set(spots.map((s) => `${s.file}:${s.line}`)), changeSet, localTo)
         : [];
+    const unresolved = grep ? withTemplateRows(textRows, rows, templateFiles ?? []) : [];
     const touched = [...new Set([...analysed.filter((f) => f.status !== "deleted").map((f) => f.path), ...listed.flatMap((r) => r.outside.map((e) => e.file))])];
     const diagnostics = semantic.diagnosticsCount(touched);
     // --- Help ---
@@ -561,6 +646,11 @@ export async function impactCommand(args, ctx) {
     if (!showVia && listed.some((r) => r.via.length > 0)) {
         help.push(`Run \`${rerun(arg, parsed, "--via")}\` for References through an interface or base member - they may reach the changed code`);
     }
+    const templated = listed.filter((r) => (r.templates?.length ?? 0) > 0).sort((a, b) => b.templates.length - a.templates.length)[0];
+    if (templated && !grep)
+        help.push(`Run \`ts-axi refs ${templated.at} --grep\` for the ${templated.templates.length} template usages of ${templated.symbol}`);
+    if (templateChanges.length > 0)
+        help.push("template_changes use a changed directive or binding - review each against that change");
     if (skipped.length > 0)
         help.push("Skipped files are not TS or JS source of the Project - review them by hand");
     const specHint = specFilesHint(ctx.cwd, opened, skipped, listed.every((r) => fileCounts(r).tests === 0));
@@ -584,6 +674,7 @@ export async function impactCommand(args, ctx) {
                     refs_outside: r.outside.length,
                     via: r.via.length,
                     ...(gap > 0 ? { textual: r.textual ? r.textual.matches : "-" } : {}),
+                    ...(rows.some((x) => x.template) ? { templates: r.templates ? r.templates.length : "-" } : {}),
                     ...fileCounts(r),
                 })),
                 ...(refRows.length > 0 ? { refs: refRows } : {}),
@@ -593,6 +684,7 @@ export async function impactCommand(args, ctx) {
         ...(notes.length > 0 ? { notes } : {}),
         ...(localOnly.length > 0 ? { local_only: localOnlyLine(localOnly.map((r) => `${r.symbol} ${r.change.change}`)) } : {}),
         ...(fileLevel.length > 0 ? { file_level: fileLevel } : {}),
+        ...(templateChanges.length > 0 ? capped("template_changes", templateChanges) : {}),
         ...capped("blind_spots", spots),
         ...(grep ? capped("unresolved", unresolved) : {}),
         ...depthLevels(semantic, rows, depth),

package/dist/src/commands/outline.js

@@ -12,6 +12,7 @@ flags[3]:
 output:
   one file = file + decls[n]{line,kind,name,exported,signature}; several = decls[n]{file,line,kind,name,exported,signature}
   class members follow their class as Class.member; at most ${MAX_ROWS} rows
+  kind state = a ui-router / ngRoute state as states.<name> (routes.<path>); its callbacks follow as states.<name>.resolve.<key> / states.<name>.onEnter
 examples[3]:
   ts-axi outline src/models/user.ts
   ts-axi outline src/models/user.ts --exported

package/dist/src/commands/refs.js

@@ -1,11 +1,12 @@
 import { relative, sep } from "node:path";
 import { bool, expectPositionals, flag, intFlag, parseArgs } from "../args.js";
 import { importerClosure } from "../importers.js";
-import { isUntyped, textualCount, textualHint, textualLine, textualMatches } from "./impact.js";
+import { isPlainLocal, isUntyped, textualCount, textualHint, textualLine, textualMatches } from "./impact.js";
 import { findOutsideProject, nearestTsconfig } from "../project.js";
 import { viaLine } from "../references.js";
 import { block, helpBlock, out } from "../render.js";
 import { importerIndexFor, REFS_HOPS, scopeFields, scopeHelp, semanticFor } from "../scope.js";
+import { loadTemplates, templatesLine, templateTarget, templateUsages } from "../templates.js";
 import { byDepthThenPath } from "../walk.js";
 import { detectWorkspace, isMultiProject } from "../workspace.js";
 import { isTestFile } from "../settings.js";
@@ -14,7 +15,7 @@ import { contextOf, declarationAt, filterSuffix, lineOf, MATCH_ROWS, matchRows,
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
 const DEPTH_ROWS = 50;
-const SHARED_FLAGS = `--kind <function|class|method|property|variable|interface|type|enum|enum-member|namespace> (narrows a name), --in <dir|glob> (repeatable; Declarations in these files), --exported, --fuzzy, --limit <1-${MAX_LIMIT}> (default ${DEFAULT_LIMIT} rows), --test-glob <glob> (repeatable; extra Test file pattern), --via (adds via rows with a via column), -P <tsconfig>, --json`;
+const SHARED_FLAGS = `--kind <function|class|method|property|variable|interface|type|enum|enum-member|namespace|state> (narrows a name), --in <dir|glob> (repeatable; Declarations in these files), --exported, --fuzzy, --limit <1-${MAX_LIMIT}> (default ${DEFAULT_LIMIT} rows), --test-glob <glob> (repeatable; extra Test file pattern), --via (adds via rows with a via column), -P <tsconfig>, --json`;
 const VIA_DOC = `via_interface: n (Iface.member) = References through an interface or base member the Symbol implements or overrides - they MAY reach it; not in refs_total
   via_implementations: n (Impl.member) = References to implementations or overrides of the Symbol; not in refs_total
   implementations: n = members that implement or override the Symbol (their Declarations are never refs)
@@ -22,7 +23,8 @@ const VIA_DOC = `via_interface: n (Iface.member) = References through an interfa
   refs_total: 0 under -P in a workspace lists found_outside_project[n]{file,line} = importers outside that Project
   scope = in a monorepo without -P the program is the declaring file + its importers (scope_partial: true when the importer scan was capped)
   tsconfig: x (n referenced configs) = a references-only tsconfig expanded to the configs it references
-  textual: n matches in m files = whole-word count of the name in Project files (JavaScript declarations and implicit projects); above refs_total = uses the checker cannot resolve - see refs --grep`;
+  textual: n matches in m files = whole-word count of the name in Project files (JavaScript declarations and implicit projects); 'n matches in this file' for a non-exported local; above refs_total = uses the checker cannot resolve - see refs --grep
+  templates: n usages in m files = template uses (.html .htm .ejs .hbs .njk .pug) of a directive or component (<wap-select / wap-select / data-wap-select), its bindings (fallback-display-property= on that tag), a controller (ng-controller) or a filter (| money); refs --grep lists them in unresolved`;
 export const REFS_HELP = `usage: ts-axi refs <name | Class.member | path:line[:col]> [flags]
 flags[12]:
   ${SHARED_FLAGS}
@@ -148,12 +150,37 @@ async function run(args, ctx, invoked) {
     const header = { ...warning, ...projectFields(opened), symbol, kind, declared_at: declaredAt };
     const explicit = Boolean(project || opened.settings.project);
     const declaredFile = decl?.file ?? (def && def.line > 0 ? def.file : undefined);
-    const textual = declaredFile !== undefined && isUntyped(opened, decl, declaredFile) ? textualCount(opened, symbol.split(".").pop()) : undefined;
-    const o = { started, symbol, declaredAt, show, scope, explicit, label, name, absFile: resolved.absFile, ...(decl ? { decl } : {}), ...(textual ? { textual } : {}) };
+    const localFile = isPlainLocal(decl) ? opened.index.abs(decl.file) : undefined;
+    const textual = declaredFile !== undefined && isUntyped(opened, decl, declaredFile) ? textualCount(opened, symbol.split(".").pop(), new Map(), localFile) : undefined;
+    const tplTarget = decl ? templateTarget(decl, opened.index.declarations(opened.index.abs(decl.file))) : undefined;
+    const templates = tplTarget ? templateRows(loadTemplates(opened.root), tplTarget) : undefined;
+    const o = { started, symbol, declaredAt, show, scope, explicit, label, name, absFile: resolved.absFile, ...(decl ? { decl } : {}), ...(textual ? { textual } : {}), ...(templates ? { templates } : {}) };
     return mode === "calls"
         ? renderCallers(semantic, opened, resolved, header, { ...o, limit, depth })
         : renderRefs(semantic, opened, resolved, header, { ...o, limit, kind });
 }
+/** Template usages as `--grep` rows. */
+export function templateRows(files, target) {
+    const texts = new Map(files.map((f) => [f.rel, f.text]));
+    return templateUsages(files, target).map((u) => ({ file: u.file, line: u.line, context: contextOf(lineOf(texts.get(u.file), u.line), u.col) }));
+}
+/** `templates` field and the hint to list them. */
+function templateFields(o, grepShown) {
+    if (!o.templates)
+        return { fields: {}, help: [] };
+    const n = o.templates.length;
+    return {
+        fields: { templates: templatesLine(o.templates) },
+        help: n > 0 && !grepShown ? [`Run \`ts-axi refs ${o.declaredAt} --grep\` for the ${n} template usages`] : [],
+    };
+}
+/** Textual rows plus template rows, one per file:line, sorted. */
+function withTemplates(unresolved, templates) {
+    if (!templates || templates.length === 0)
+        return unresolved;
+    const seen = new Set(unresolved.map((u) => `${u.file}:${u.line}`));
+    return [...unresolved, ...templates.filter((t) => !seen.has(`${t.file}:${t.line}`))].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+}
 const OUTSIDE_ROWS = 5;
 /**
  * No References under an explicit Project: importers of the declaring file (or of a barrel
@@ -215,7 +242,7 @@ function viaFields(via, bases) {
 }
 /** Whole-word matches of the name on lines that hold no known position (what `--grep` lists). */
 function unresolvedOf(opened, semantic, o, known) {
-    return textualMatches(opened, semantic, [o.symbol.split(".").pop()], new Set(known.map((r) => `${r.file}:${r.line}`)), new Set(o.decl ? [`${o.decl.file}:${o.decl.line}`, `${o.decl.file}:${o.decl.nameLine}`] : []), new Map());
+    return textualMatches(opened, semantic, [o.symbol.split(".").pop()], new Set(known.map((r) => `${r.file}:${r.line}`)), new Set(o.decl ? [`${o.decl.file}:${o.decl.line}`, `${o.decl.file}:${o.decl.nameLine}`] : []), new Map(), isPlainLocal(o.decl) ? new Map([[o.decl.name, opened.index.abs(o.decl.file)]]) : new Map());
 }
 /**
  * `textual` field and, when the name occurs more often than refs_total and some matches sit on no
@@ -256,12 +283,16 @@ function renderRefs(semantic, opened, resolved, header, o) {
     const outside = rows.length === 0 ? outsideImporters(opened, o) : { fields: {}, help: [] };
     help.unshift(...outside.help);
     const word = o.symbol.split(".").pop();
-    const unresolved = o.show.grep || o.textual ? unresolvedOf(opened, semantic, o, [...rows, ...via, ...impls]) : [];
-    const text = textualFields(o, rows.length, unresolved.length, o.show.grep);
+    const unresolved = o.show.grep || o.textual || o.templates ? unresolvedOf(opened, semantic, o, [...rows, ...via, ...impls]) : [];
+    const grepRows = withTemplates(unresolved, o.templates);
+    // The --grep hint counts what --grep lists: textual and template rows together.
+    const text = textualFields(o, rows.length, grepRows.length, o.show.grep);
+    const tpl = templateFields(o, o.show.grep || text.help.length > 0);
     if (text.help.length > 0)
         help.unshift(...text.help);
-    else if (o.decl?.nameless && !o.show.grep)
+    else if (o.decl?.nameless && !o.show.grep && tpl.help.length === 0)
         help.unshift(`Run \`ts-axi refs ${o.declaredAt} --grep\` for textual matches of '${word}'`);
+    help.unshift(...tpl.help);
     if (isFunctionLike(o.kind))
         help.push(`Run \`ts-axi callers ${o.declaredAt}\` for call sites with their enclosing function`);
     help.push(`Run \`ts-axi def ${o.declaredAt}\` for the declaration body`);
@@ -271,6 +302,7 @@ function renderRefs(semantic, opened, resolved, header, o) {
         ...(o.decl?.nameless ? { note: NAMELESS_NOTE } : {}),
         refs_total: rows.length,
         ...text.fields,
+        ...tpl.fields,
         files,
         tests,
         ...viaFields(via, split.bases),
@@ -288,8 +320,8 @@ function renderRefs(semantic, opened, resolved, header, o) {
                 })),
             }),
         ...(truncated ? { truncated: true } : {}),
-        ...(o.show.grep ? { unresolved: unresolved.length === 0 ? 0 : unresolved.slice(0, o.limit) } : {}),
-        ...(unresolved.length > o.limit ? { unresolved_total: unresolved.length } : {}),
+        ...(o.show.grep ? { unresolved: grepRows.length === 0 ? 0 : grepRows.slice(0, o.limit) } : {}),
+        ...(grepRows.length > o.limit ? { unresolved_total: grepRows.length } : {}),
         ...outside.fields,
         ...scopeFields(o.scope),
         ...footer(semantic, o.started, fileList),
@@ -334,9 +366,12 @@ function renderCallers(semantic, opened, resolved, header, o) {
             const split = semantic.referenceSplit(resolved.absFile, resolved.pos);
             const known = [...split.direct, ...split.declarations, ...split.via, ...split.implementations, ...split.dropped, ...(sites ?? [])];
             const calls = (sites ?? []).filter((s) => s.via === undefined).length;
-            return textualFields(o, calls, unresolvedOf(opened, semantic, o, known).length, false);
+            return textualFields(o, calls, withTemplates(unresolvedOf(opened, semantic, o, known), o.templates).length, false);
         })()
         : { fields: {}, help: [] };
+    const tpl = templateFields(o, callerText.help.length > 0);
+    callerText.fields = { ...callerText.fields, ...tpl.fields };
+    callerText.help = [...tpl.help, ...callerText.help];
     if (sites === undefined) {
         return out(block({ ...header, refs_total: 0, ...callerText.fields, note: "not callable - no call hierarchy for this Symbol", ...scopeFields(o.scope), ...footer(semantic, o.started, []) }), helpBlock([...callerText.help, `Run \`ts-axi refs ${o.declaredAt}\` for every Reference`]));
     }

package/dist/src/project.js

@@ -254,7 +254,9 @@ export function createSyntacticIndex(root, project) {
             return list;
         },
         findDeclarations(query) {
-            const needle = query.fuzzy ? query.name.toLowerCase() : query.name;
+            // A nested holder (`states.cart`) may never be spelled in the file: prefilter on the member.
+            const word = query.member ?? query.name;
+            const needle = query.fuzzy ? word.toLowerCase() : word;
             const result = [];
             for (const file of index.files) {
                 const text = index.text(file);

package/dist/src/symbols.js

@@ -13,6 +13,7 @@ export const KINDS = [
     "enum",
     "enum-member",
     "namespace",
+    "state",
 ];
 export const SIGNATURE_MAX = 160;
 const FUNCTION_LIKE = new Set(["function", "method"]);
@@ -228,6 +229,13 @@ function nameText(name, sf) {
 const REGISTRATION_VERBS = new Set(["controller", "service", "factory", "directive", "filter", "component", "run", "config", "provider"]);
 /** Verbs whose callback is a constructor: its `this.x = function` statements are members. */
 const CONSTRUCTOR_VERBS = new Set(["controller", "service", "provider"]);
+/** Router providers whose `.state(...)` / `.when(...)` calls declare a state (ui-router, ngRoute). */
+const STATE_PROVIDER = /^\$?stateProvider$/i;
+const ROUTE_PROVIDER = /^\$?routeProvider$/i;
+/** Keys that, next to a string `name`, make an array element a ui-router state object. */
+const STATE_KEYS = new Set(["url", "resolve", "component", "controller", "template", "templateUrl", "views", "abstract"]);
+/** Directive definition keys whose object literal lists the bindings. */
+const BINDING_KEYS = new Set(["scope", "bindToController", "bindings"]);
 /** `Template.x.<hook>(fn)` lifecycle callbacks. */
 const TEMPLATE_HOOKS = new Set(["onCreated", "onRendered", "onDestroyed"]);
 function unwrap(expr) {
@@ -378,6 +386,7 @@ export function collectDeclarations(sf, file) {
         if (verb === "component" && arg && ts.isObjectLiteralExpression(arg)) {
             nested({ start, end: arg.end, kind: "variable", name, exported: true, signature: `component ${name}`, namePos: arg.getStart(sf), nameless: true });
             objectMembers(arg, name, true);
+            bindingMembers(arg, name);
             return;
         }
         const fn = registeredFunction(arg);
@@ -403,9 +412,182 @@ export function collectDeclarations(sf, file) {
             thisMembers(fn.body, name, true);
         if (verb === "factory" || verb === "service")
             returnedMembers(fn.body, name);
+        if (verb === "directive")
+            for (const obj of returnedObjects(fn.body))
+                bindingMembers(obj, name);
+        if (verb === "config" || verb === "run")
+            routerBody(fn.body);
     };
+    /** Object literals a function returns at its top level (a directive definition object). */
+    const returnedObjects = (body) => {
+        const direct = unwrap(body);
+        if (ts.isObjectLiteralExpression(direct))
+            return [direct];
+        if (!ts.isBlock(body))
+            return [];
+        return body.statements.flatMap((st) => (ts.isReturnStatement(st) && st.expression && ts.isObjectLiteralExpression(unwrap(st.expression)) ? [unwrap(st.expression)] : []));
+    };
+    /** `scope: { x: '=' }` / `bindToController` / `bindings` keys as `property` Declarations `<owner>.x`. */
+    const bindingMembers = (obj, owner) => {
+        for (const prop of obj.properties) {
+            if (!ts.isPropertyAssignment(prop) || !BINDING_KEYS.has(nameText(prop.name, sf) ?? ""))
+                continue;
+            const bindings = unwrap(prop.initializer);
+            if (!ts.isObjectLiteralExpression(bindings))
+                continue;
+            for (const b of bindings.properties) {
+                const name = nameText(b.name, sf);
+                if (!name || !b.name || !ts.isPropertyAssignment(b))
+                    continue;
+                nested({ start: b.getStart(sf), end: b.end, kind: "property", name, parentName: owner, exported: true, signature: tokenText(b, sf, b.getStart(sf), b.end), namePos: b.name.getStart(sf) });
+            }
+        }
+    };
+    /** Function-valued properties of a state object (`resolve.x`, `onEnter`, `views.main.controller`) as methods; nested objects recurse. */
+    const stateMembers = (obj, holder, depth) => {
+        for (const prop of obj.properties) {
+            const name = nameText(prop.name, sf);
+            if (!name || !prop.name)
+                continue;
+            if (ts.isMethodDeclaration(prop)) {
+                nested({ start: prop.getStart(sf), end: prop.end, kind: "method", name, parentName: holder, exported: true, signature: fullSignatureOf(prop, sf), namePos: prop.name.getStart(sf) });
+            }
+            else if (ts.isPropertyAssignment(prop)) {
+                const value = unwrap(prop.initializer);
+                const fn = registeredFunction(value);
+                if (fn)
+                    nested({ start: prop.getStart(sf), end: prop.end, kind: "method", name, parentName: holder, exported: true, signature: `${name}${paramsText(fn, sf)}`, namePos: prop.name.getStart(sf) });
+                else if (ts.isObjectLiteralExpression(value) && depth < 3)
+                    stateMembers(value, `${holder}.${name}`, depth + 1);
+            }
+        }
+    };
+    /** Same-file string consts (`const base = 'main.x'`), for state names built from them; ambiguous names dropped. */
+    let stringConsts;
+    const constValue = (id, depth) => {
+        if (!stringConsts) {
+            stringConsts = new Map();
+            const visit = (node) => {
+                if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+                    const init = unwrap(node.initializer);
+                    if (isStringName(init) || ts.isTemplateExpression(init))
+                        stringConsts.set(node.name.text, stringConsts.has(node.name.text) ? null : init);
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(sf);
+        }
+        const init = stringConsts.get(id);
+        return init && depth < 3 ? stateNameOf(init, depth + 1) : undefined;
+    };
+    /** A literal, a template literal (`${...}` = a same-file string const, else `*`) or a const identifier. */
+    const stateNameOf = (expr, depth = 0) => {
+        const e = unwrap(expr);
+        if (isStringName(e))
+            return e.text;
+        if (ts.isTemplateExpression(e)) {
+            return e.head.text + e.templateSpans.map((s) => (ts.isIdentifier(s.expression) ? (constValue(s.expression.text, depth) ?? "*") : "*") + s.literal.text).join("");
+        }
+        if (ts.isIdentifier(e))
+            return constValue(e.text, depth) ?? e.text;
+        return undefined;
+    };
+    const propOf = (obj, key) => obj.properties.find((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) && nameText(p.name, sf) === key);
+    /** `name` of a state object literal: `name: 'x'`, `` name: `${base}.x` ``, `name: base` or `{ name }`. */
+    const stateObjectName = (obj) => {
+        const prop = propOf(obj, "name");
+        if (prop && ts.isPropertyAssignment(prop))
+            return stateNameOf(prop.initializer);
+        if (prop && ts.isShorthandPropertyAssignment(prop))
+            return stateNameOf(prop.name);
+        return undefined;
+    };
+    /** A ui-router state object (`.state()` argument or array element) or an ngRoute config as a `state` Declaration plus its callbacks. */
+    const stateFromObject = (obj, name, start, end, route) => {
+        const url = propOf(obj, "url");
+        const urlText = url && ts.isPropertyAssignment(url) && isStringName(url.initializer) ? url.initializer.text : undefined;
+        const parent = route ? "routes" : "states";
+        // Plain-literal options are compared, not displayed: a new controller or template is a contract change.
+        const options = obj.properties
+            .filter((p) => ts.isPropertyAssignment(p) && nameText(p.name, sf) !== "name" && nameText(p.name, sf) !== "url")
+            .filter((p) => isStringName(p.initializer) || p.initializer.kind === ts.SyntaxKind.TrueKeyword || p.initializer.kind === ts.SyntaxKind.FalseKeyword)
+            .map((p) => tokenText(p, sf, p.getStart(sf), p.end));
+        nested({
+            start,
+            end,
+            kind: "state",
+            name,
+            parentName: parent,
+            exported: true,
+            signature: `${route ? "route" : "state"} ${name}${urlText !== undefined && !route ? ` (url ${urlText})` : ""}${options.length > 0 ? `\n${options.join("; ")}` : ""}`,
+            namePos: obj.getStart(sf),
+            nameless: true,
+        });
+        stateMembers(obj, `${parent}.${name}`, 1);
+    };
+    /** One `.state('name', {...})`, `.state({ name, ... })` or `.when('/path', {...})` call. */
+    const stateCall = (call, route) => {
+        const [first, second] = call.arguments;
+        const obj = first && ts.isObjectLiteralExpression(first) && !route ? first : second && ts.isObjectLiteralExpression(second) ? second : undefined;
+        if (!obj)
+            return;
+        const name = isStringName(first) ? first.text : route ? undefined : stateObjectName(obj);
+        if (name === undefined)
+            return;
+        stateFromObject(obj, name, call.expression.name.getStart(sf), call.end, route);
+    };
+    /** State objects among the elements of an array literal, or of `[...].concat([...], ...)`; other values ignored. */
+    const stateArray = (expr) => {
+        const e = unwrap(expr);
+        if (ts.isArrayLiteralExpression(e)) {
+            for (const el of e.elements) {
+                const obj = unwrap(el);
+                if (!ts.isObjectLiteralExpression(obj) || !obj.properties.some((p) => STATE_KEYS.has(nameText(p.name, sf) ?? "")))
+                    continue;
+                const name = stateObjectName(obj);
+                if (name !== undefined)
+                    stateFromObject(obj, name, obj.getStart(sf), obj.end, false);
+            }
+        }
+        else if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) && e.expression.name.text === "concat") {
+            stateArray(e.expression.expression);
+            for (const arg of e.arguments)
+                stateArray(arg);
+        }
+    };
+    /** `$stateProvider.state(...).state(...)` and `$routeProvider.when(...)` chains; `.otherwise()` ignored. */
+    const routerChain = (expr) => {
+        const calls = [];
+        let e = unwrap(expr);
+        while (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression)) {
+            calls.push(e);
+            e = e.expression.expression;
+        }
+        if (!ts.isIdentifier(e))
+            return false;
+        const route = ROUTE_PROVIDER.test(e.text);
+        if (!route && !STATE_PROVIDER.test(e.text))
+            return false;
+        for (const call of calls.reverse()) {
+            const verb = call.expression.name.text;
+            if (verb === (route ? "when" : "state"))
+                stateCall(call, route);
+        }
+        return true;
+    };
+    /** Router chains at the top level of a `.config` / `.run` callback or of a function taking a router provider. */
+    const routerBody = (body) => {
+        if (!body || !ts.isBlock(body))
+            return;
+        for (const statement of body.statements)
+            if (ts.isExpressionStatement(statement))
+                routerChain(statement.expression);
+    };
+    const takesRouter = (fn) => fn.parameters.some((p) => ts.isIdentifier(p.name) && (STATE_PROVIDER.test(p.name.text) || ROUTE_PROVIDER.test(p.name.text)));
     /** Registrations along a call chain (`angular.module('x').controller(...).service(...)`), in source order. */
     const callChain = (expr) => {
+        if (routerChain(expr))
+            return;
         const calls = [];
         let e = unwrap(expr);
         while (ts.isCallExpression(e)) {
@@ -446,8 +628,12 @@ export function collectDeclarations(sf, file) {
         if (target === "module.exports") {
             if (ts.isObjectLiteralExpression(right))
                 objectMembers(right, "exports", true);
+            else
+                stateArray(right);
             return;
         }
+        if (target === `exports.${left.name.text}` || target === `module.exports.${left.name.text}`)
+            stateArray(right);
         const owner = left.expression;
         if (ts.isPropertyAccessExpression(owner) && owner.name.text === "prototype" && ts.isIdentifier(owner.expression)) {
             const cls = owner.expression.text;
@@ -478,6 +664,8 @@ export function collectDeclarations(sf, file) {
                 add(statement, statement.name, statement.name.text, false);
             if (isConstructorName(statement.name.text))
                 thisMembers(statement.body, statement.name.text, inIife ? false : topLevelExported(statement.name.text));
+            if (takesRouter(statement))
+                routerBody(statement.body);
         }
         else if (ts.isVariableStatement(statement)) {
             for (const decl of statement.declarationList.declarations) {
@@ -487,8 +675,11 @@ export function collectDeclarations(sf, file) {
                 const fn = asFunction(decl.initializer);
                 if (inIife && fn)
                     add(decl, decl.name, name, false);
+                if (fn && takesRouter(fn))
+                    routerBody(fn.body);
                 const exported = inIife ? false : topLevelExported(name);
                 const init = unwrap(decl.initializer);
+                stateArray(init);
                 if (ts.isObjectLiteralExpression(init))
                     objectMembers(init, name, exported);
                 else if (fn && isConstructorName(name))
@@ -512,6 +703,9 @@ export function collectDeclarations(sf, file) {
             else
                 callChain(expr);
         }
+        else if (ts.isExportAssignment(statement)) {
+            stateArray(statement.expression);
+        }
         else if (ts.isIfStatement(statement)) {
             scriptStatement(statement.thenStatement, inIife);
             if (statement.elseStatement)

package/dist/src/templates.js

@@ -0,0 +1,138 @@
+// Template usages of AngularJS-style registrations: directives and components as kebab-case
+// elements/attributes, their bindings as attributes, controllers in `ng-controller`, filters
+// after `|`. One regex pass per template line, no HTML parsing.
+import { readFileSync } from "node:fs";
+import { listFiles, toRel } from "./walk.js";
+export const TEMPLATE_EXTENSIONS = [".html", ".htm", ".ejs", ".hbs", ".njk", ".pug"];
+export function isTemplatePath(path) {
+    return TEMPLATE_EXTENSIONS.some((ext) => path.endsWith(ext));
+}
+/** `wapSelect` → `wap-select`. */
+export function kebab(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function escape(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Opening tag `<wap-select` or attribute `wap-select` / `data-wap-select` / `x-wap-select`. */
+function elementOrAttribute(name) {
+    return new RegExp(`(?:<|[\\s"'])(?:data-|x-)?${escape(kebab(name))}(?![\\w-])`, "g");
+}
+/** A Declaration's template form; undefined when templates cannot name it. */
+export function templateTarget(decl, fileDecls) {
+    const isComponent = (d) => d !== undefined && d.nameless === true && d.signature.startsWith("component ");
+    if (decl.nameless && (decl.parentName === "directive" || isComponent(decl)))
+        return { symbol: decl.qualifiedName, pattern: elementOrAttribute(decl.name) };
+    if (decl.nameless && decl.parentName === "controller") {
+        return { symbol: decl.qualifiedName, pattern: new RegExp(`ng-controller\\s*=\\s*["']\\s*${escape(decl.name)}(?![\\w$])`, "g") };
+    }
+    if (decl.nameless && decl.parentName === "filter")
+        return { symbol: decl.qualifiedName, pattern: new RegExp(`(?<!\\|)\\|\\s*${escape(decl.name)}(?![\\w$])`, "g") };
+    if (decl.kind === "property" && decl.parentName !== undefined) {
+        const owner = fileDecls.find((d) => d.qualifiedName === decl.parentName && d.parentName !== decl.parentName);
+        if (owner && owner.nameless && (owner.parentName === "directive" || isComponent(owner))) {
+            return {
+                symbol: decl.qualifiedName,
+                pattern: new RegExp(`\\s(?:data-|x-)?${escape(kebab(decl.name))}(?=[\\s=>/])`, "g"),
+                owner: elementOrAttribute(owner.name),
+            };
+        }
+    }
+    return undefined;
+}
+/** Template files of the repo root (git listing, else the bounded walk). */
+export function loadTemplates(root) {
+    const files = [];
+    for (const abs of listFiles(root, isTemplatePath).files) {
+        try {
+            files.push({ rel: toRel(root, abs), text: readFileSync(abs, "utf8") });
+        }
+        catch {
+            // unreadable: skipped
+        }
+    }
+    return files;
+}
+const TAG_SPAN_LINES = 40;
+/**
+ * Text of the tag open at `offset` (from its `<`), or undefined when `offset` is outside a tag or
+ * inside a quoted value. Forward scan from up to 40 lines back; `>` inside quotes does not close.
+ * Tolerant of broken markup: never throws, an unclosed quote just ends the tag at the scan point.
+ */
+function openTagBefore(text, offset, lineStarts) {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineStarts[mid] <= offset)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    let tagStart = -1;
+    let quote = "";
+    for (let i = lineStarts[Math.max(0, lo - TAG_SPAN_LINES)]; i < offset; i++) {
+        const c = text[i];
+        if (tagStart < 0) {
+            if (c === "<" && /[A-Za-z]/.test(text[i + 1] ?? ""))
+                tagStart = i;
+        }
+        else if (quote) {
+            if (c === quote)
+                quote = "";
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === ">") {
+            tagStart = -1;
+        }
+        else if (c === "<" && /[A-Za-z]/.test(text[i + 1] ?? "")) {
+            tagStart = i;
+        }
+    }
+    return tagStart < 0 || quote ? undefined : text.slice(tagStart, offset);
+}
+/** Usages of `target` in one template text: at most one per line. */
+export function usagesIn(text, target) {
+    const result = [];
+    const lineStarts = [0];
+    for (let i = 0; i < text.length; i++)
+        if (text[i] === "\n")
+            lineStarts.push(i + 1);
+    let lastLine = 0;
+    for (const m of text.matchAll(target.pattern)) {
+        // Skip the delimiter the pattern consumed (`<`, whitespace, quote, `|`).
+        const offset = (m.index ?? 0) + (/^[<\s"'|]/.test(m[0]) ? 1 : 0);
+        if (target.owner) {
+            // The attribute counts only inside a tag opened by (or carrying) the owner directive.
+            const tag = openTagBefore(text, offset, lineStarts);
+            if (tag === undefined)
+                continue;
+            target.owner.lastIndex = 0;
+            if (!target.owner.test(tag))
+                continue;
+        }
+        let lo = 0;
+        let hi = lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStarts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        const line = lo + 1;
+        if (line === lastLine)
+            continue;
+        lastLine = line;
+        result.push({ line, col: offset - lineStarts[lo] + 1 });
+    }
+    return result;
+}
+export function templateUsages(files, target) {
+    return files.flatMap((f) => usagesIn(f.text, target).map((u) => ({ file: f.rel, ...u })));
+}
+export function templatesLine(usages) {
+    return `${usages.length} usages in ${new Set(usages.map((u) => u.file)).size} files`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-axi",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "AXI-compliant TypeScript symbol CLI for agents - definitions, references, callers, file outlines and change impact (blast radius) with token-efficient TOON output",
   "type": "module",
   "keywords": [