ts-axi 0.1.3 → 0.1.4

package/README.md

@@ -116,6 +116,7 @@ One dependency: the `typescript` compiler API (ADR in `docs/adr/0001-typescript-
 - `outline`, `def` and the home view only parse files (`ts.createSourceFile`): no tsconfig needed, well under a second.
 - `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.
+- 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.
 - 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/common.js

@@ -96,35 +96,89 @@ export function positionOf(group) {
     const d = group.decls[0];
     return `${d.file}:${d.nameLine}`;
 }
+/** Ambiguity lists stop here; the narrowing hints cover the rest. */
+export const MATCH_ROWS = 20;
+/** `matches` (first MATCH_ROWS, shallowest first) plus `matches_total` / `truncated` past that. */
 export function matchRows(groups) {
-    return groups.map((g) => ({
+    const rows = groups.slice(0, MATCH_ROWS).map((g) => ({
         file: g.primary.file,
         line: g.decls[0].nameLine,
         kind: g.primary.kind,
         exported: g.primary.exported,
         signature: g.decls[0].signature,
     }));
+    return { matches: rows, ...(groups.length > MATCH_ROWS ? { matches_total: groups.length, truncated: true } : {}) };
 }
-/** Concrete hints that narrow an ambiguous name to one Symbol. */
-export function narrowHints(command, groups, f, label) {
+function countBy(items, key) {
+    const counts = new Map();
+    for (const item of items) {
+        const k = key(item);
+        if (k !== undefined)
+            counts.set(k, (counts.get(k) ?? 0) + 1);
+    }
+    return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+}
+/** Longest common directory of `files` ('' when they share none). */
+function commonDir(files) {
+    const split = files.map((f) => posix.dirname(f).split("/").filter((p) => p !== "" && p !== "."));
+    const first = split[0] ?? [];
+    let n = 0;
+    while (n < first.length && split.every((parts) => parts[n] === first[n]))
+        n++;
+    return first.slice(0, n).join("/");
+}
+const IDENT_PART = /^[A-Za-z_$][\w$]*$/;
+/** Root-relative path → the form `--in` expects (relative to cwd). */
+function cwdGlob(ctx, rootRel) {
+    const prefix = relative(ctx.root, ctx.cwd).split(sep).join("/");
+    if (!prefix || prefix.startsWith(".."))
+        return rootRel;
+    return posix.relative(prefix, rootRel) || ".";
+}
+/** Concrete hints that narrow an ambiguous name, computed from the matches themselves. */
+export function narrowHints(ctx, command, groups, f, label, target) {
+    const total = groups.length;
     const hints = groups.slice(0, 2).map((g) => `Run \`ts-axi ${command} ${positionOf(g)}\` for the one in ${g.primary.file}`);
-    const first = groups[0].primary;
-    const dirs = new Set(groups.map((g) => posix.dirname(g.primary.file)));
-    const dir = posix.dirname(first.file);
-    if (dirs.size > 1 && [...dirs].filter((d) => d === dir || d.startsWith(`${dir}/`)).length === 1) {
-        hints.push(`Run \`ts-axi ${command} ${label} --in ${dir}\` to keep matches below ${dir}`);
+    const files = groups.map((g) => g.primary.file);
+    // --in: the subtrees right below the common directory, largest first.
+    const prefix = commonDir(files);
+    const below = countBy(files, (file) => {
+        const rest = (prefix ? file.slice(prefix.length + 1) : file).split("/");
+        return rest.length > 1 ? posix.join(prefix, rest[0]) : file;
+    });
+    if (below.length > 1) {
+        for (const [dir, n] of below.slice(0, 2))
+            hints.push(`Run \`ts-axi ${command} ${label} --in ${cwdGlob(ctx, dir)}\` to keep ${n} of ${total}`);
+    }
+    else if (prefix) {
+        hints.push(`Run \`ts-axi ${command} ${label} --in ${cwdGlob(ctx, prefix)}\` - all ${total} are below ${prefix}`);
     }
-    else {
-        hints.push(`Run \`ts-axi ${command} ${label} --in ${first.file}\` to keep matches in one file`);
+    if (!f.kind) {
+        const kinds = countBy(groups, (g) => g.primary.kind);
+        if (kinds.length > 1)
+            for (const [kind, n] of kinds.slice(0, 3))
+                hints.push(`Run \`ts-axi ${command} ${label} --kind ${kind}\` to keep ${n} of ${total}`);
     }
-    const kinds = new Set(groups.map((g) => g.primary.kind));
-    if (kinds.size > 1 && !f.kind)
-        hints.push(`Run \`ts-axi ${command} ${label} --kind ${first.kind}\` to keep one kind`);
-    if (!f.exported && groups.some((g) => g.primary.exported) && groups.some((g) => !g.primary.exported)) {
-        hints.push(`Run \`ts-axi ${command} ${label} --exported\` to keep exported Declarations`);
+    if (target && target.member === undefined) {
+        const parents = countBy(groups, (g) => g.primary.parentName?.split(".").pop());
+        const distinct = parents.length > 1 || (parents.length === 1 && groups.some((g) => g.primary.parentName === undefined));
+        if (distinct) {
+            for (const [parent, n] of parents.filter(([p]) => IDENT_PART.test(p)).slice(0, 2)) {
+                hints.push(`Run \`ts-axi ${command} ${parent}.${target.name}${filterSuffixOf(label, target)}\` to keep ${n} of ${total}`);
+            }
+        }
+    }
+    const exported = groups.filter((g) => g.primary.exported).length;
+    if (!f.exported && exported > 0 && exported < total) {
+        hints.push(`Run \`ts-axi ${command} ${label} --exported\` to keep ${exported} of ${total}`);
     }
     return hints;
 }
+/** The flags part of a hint label (`label` = target + filter suffix). */
+function filterSuffixOf(label, target) {
+    const bare = target.member ? `${target.name}.${target.member}` : target.name;
+    return label.startsWith(bare) ? label.slice(bare.length) : "";
+}
 export function resolvePositionFile(cwd, file) {
     const abs = resolve(cwd, file);
     if (!existsSync(abs)) {
@@ -176,6 +230,10 @@ export function resolvePosition(index, cwd, target) {
         const hit = onLine.find((id) => id.getStart(sf) <= offset && offset <= id.end) ?? onLine.find((id) => id.getStart(sf) >= offset);
         return hit ? pick(hit) : { kind: "none", abs, file, reason: `no identifier at ${file}:${target.line}:${target.col}` };
     }
+    // A string-registered name has no identifier: its line stands for it.
+    const nameless = decls.find((d) => d.nameless && d.nameLine === target.line);
+    if (nameless)
+        return { kind: "decl", decl: nameless, abs };
     if (onLine.length === 0)
         return { kind: "none", abs, file, reason: `no identifier on ${file}:${target.line}` };
     const constructorDecl = decls.find((d) => d.nameLine === target.line && d.name === "constructor");

package/dist/src/commands/def.js

@@ -2,13 +2,13 @@ import { bool, expectPositionals, flag, parseArgs } from "../args.js";
 import { semanticFor } from "../scope.js";
 import { block, fenced, helpBlock, out } from "../render.js";
 import { isFunctionLike, kindFromScriptElement, parseTarget } from "../symbols.js";
-import { BODY_LINES, declarationAt, filterSuffix, matchRows, narrowHints, numberedLines, open, positionStartDir, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, readFilters, } from "./common.js";
+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
 output:
   1 match = file, line, kind, exported, signature + body fenced with file line numbers
-  several = matches[n]{file,line,kind,exported,signature} + how to narrow
+  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
   none = matches: 0 + did_you_mean
 examples[5]:
   ts-axi def User
@@ -91,6 +91,6 @@ export async function defCommand(args, ctx) {
     return out(block({
         ...(opened.warning ? { warning: opened.warning } : {}),
         symbol: label,
-        matches: matchRows(groups),
-    }), helpBlock(narrowHints("def", groups, f, `${label}${filterSuffix(f, project)}`)));
+        ...matchRows(groups),
+    }), helpBlock(narrowHints(opened, "def", groups, f, `${label}${filterSuffix(f, project)}`, target)));
 }

package/dist/src/commands/impact.js

@@ -227,7 +227,8 @@ function blindSpots(semantic, names, changeSet) {
 function walkExtra(dir, outFiles) {
     outFiles.push(...walkFiles(dir, { accept: (name) => GREP_EXTRA.some((ext) => name.endsWith(ext)) }).files);
 }
-function textualMatches(opened, semantic, names, known, skipLines, changeSet) {
+/** Whole-word matches of `names` in Project files and templates that are not `known` References. */
+export function textualMatches(opened, semantic, names, known, skipLines, changeSet) {
     const files = [...semantic.projectFiles];
     const projectSet = new Set(files);
     walkExtra(opened.root, files);

package/dist/src/commands/refs.js

@@ -1,6 +1,7 @@
 import { relative, sep } from "node:path";
 import { bool, expectPositionals, flag, intFlag, parseArgs } from "../args.js";
 import { importerClosure } from "../importers.js";
+import { textualMatches } from "./impact.js";
 import { findOutsideProject, nearestTsconfig } from "../project.js";
 import { viaLine } from "../references.js";
 import { block, helpBlock, out } from "../render.js";
@@ -9,7 +10,7 @@ import { byDepthThenPath } from "../walk.js";
 import { detectWorkspace, isMultiProject } from "../workspace.js";
 import { isTestFile } from "../settings.js";
 import { isFunctionLike, kindFromScriptElement, parseTarget } from "../symbols.js";
-import { contextOf, declarationAt, filterSuffix, lineOf, matchRows, narrowHints, open, positionStartDir, projectFields, readFilters, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, } from "./common.js";
+import { contextOf, declarationAt, filterSuffix, lineOf, MATCH_ROWS, matchRows, narrowHints, open, positionStartDir, projectFields, readFilters, resolveNameTarget, resolvePosition, suggestions, TARGET_FLAGS, targetLabel, } from "./common.js";
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
 const DEPTH_ROWS = 50;
@@ -22,14 +23,16 @@ const VIA_DOC = `via_interface: n (Iface.member) = References through an interfa
   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`;
 export const REFS_HELP = `usage: ts-axi refs <name | Class.member | path:line[:col]> [flags]
-flags[11]:
+flags[12]:
   ${SHARED_FLAGS}
   --implementations (lists implementations[n]{file,line,symbol} instead of the count)
+  --grep (adds unresolved[n]{file,line,context} - textual matches of the name that are not References; also searches .astro/.vue/.svelte/.mdx/.html)
   --kind calls = same as \`ts-axi callers\`
 output:
   symbol, kind, declared_at, refs_total, files, tests, refs[n]{file,line,context} (Declarations excluded), elapsed_ms
   ${VIA_DOC}
-  an ambiguous name lists matches[n] + the disambiguated forms; nothing is analysed
+  note = the name is registered by a string ('Name' in .controller('Name', fn)) - its uses are textual; add --grep
+  an ambiguous name lists matches[n] (at most ${MATCH_ROWS}; matches_total + truncated past that) + the narrowing forms; nothing is analysed
 examples[4]:
   ts-axi refs User.save
   ts-axi refs src/models/user.ts:12
@@ -62,7 +65,7 @@ async function run(args, ctx, invoked) {
         { name: "--limit" },
         { name: "--test-glob", repeatable: true },
         { name: "--via", boolean: true },
-        ...(invoked === "calls" ? [{ name: "--depth" }] : [{ name: "--implementations", boolean: true }]),
+        ...(invoked === "calls" ? [{ name: "--depth" }] : [{ name: "--implementations", boolean: true }, { name: "--grep", boolean: true }]),
     ];
     const parsed = parseArgs(args, specs, command);
     const [raw] = expectPositionals(parsed, 1, `${command} <name | Class.member | path:line[:col]> [flags]`);
@@ -74,7 +77,11 @@ async function run(args, ctx, invoked) {
     const label = targetLabel(target);
     const project = flag(parsed, "-P");
     const name = mode === "calls" ? "callers" : "refs";
-    const show = { via: bool(parsed, "--via"), implementations: invoked === "refs" && bool(parsed, "--implementations") };
+    const show = {
+        via: bool(parsed, "--via"),
+        implementations: invoked === "refs" && bool(parsed, "--implementations"),
+        grep: invoked === "refs" && bool(parsed, "--grep"),
+    };
     const started = performance.now();
     const opened = open(ctx.cwd, parsed, positionStartDir(ctx.cwd, target));
     const warning = opened.warning ? { warning: opened.warning } : {};
@@ -107,7 +114,7 @@ async function run(args, ctx, invoked) {
             ]));
         }
         if (groups.length > 1) {
-            return out(block({ ...warning, symbol: label, ambiguous: `${groups.length} Symbols - pick one`, matches: matchRows(groups) }), helpBlock(narrowHints(name, groups, f, `${label}${filterSuffix(f, project)}`)));
+            return out(block({ ...warning, symbol: label, ambiguous: `${groups.length} Symbols - pick one`, ...matchRows(groups) }), helpBlock(narrowHints(opened, name, groups, f, `${label}${filterSuffix(f, project)}`, target)));
         }
         const decl = groups[0].decls[0];
         resolved = { absFile: opened.index.abs(decl.file), pos: decl.namePos, decl, seeds: [...new Set(groups[0].decls.map((d) => opened.index.abs(d.file)))] };
@@ -139,7 +146,7 @@ async function run(args, ctx, invoked) {
     const declaredAt = decl ? `${decl.file}:${decl.nameLine}` : def && def.line > 0 ? `${def.file}:${def.line}` : "(outside the Project)";
     const header = { ...warning, ...projectFields(opened), symbol, kind, declared_at: declaredAt };
     const explicit = Boolean(project || opened.settings.project);
-    const o = { started, symbol, declaredAt, show, scope, explicit, label, name, absFile: resolved.absFile };
+    const o = { started, symbol, declaredAt, show, scope, explicit, label, name, absFile: resolved.absFile, ...(decl ? { decl } : {}) };
     return mode === "calls"
         ? renderCallers(semantic, opened, resolved, header, { ...o, limit, depth })
         : renderRefs(semantic, opened, resolved, header, { ...o, limit, kind });
@@ -193,6 +200,7 @@ function footer(semantic, started, touched) {
     const diagnostics = semantic.diagnosticsCount(touched);
     return { elapsed_ms: Math.round(performance.now() - started), ...(diagnostics > 0 ? { diagnostics } : {}) };
 }
+const NAMELESS_NOTE = "registered by a string - References to it are textual (templates; DI arrays; route configs)";
 /** `via_interface` / `via_implementations` counts, plus the hint to see their rows. */
 function viaFields(via, bases) {
     const base = via.filter((v) => v.through === "base");
@@ -227,12 +235,19 @@ function renderRefs(semantic, opened, resolved, header, o) {
         help.push(`Run \`ts-axi refs ${o.declaredAt} --implementations\` to list the ${impls.length} implementations`);
     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
+        ? textualMatches(opened, semantic, [word], new Set([...rows, ...via, ...impls].map((r) => `${r.file}:${r.line}`)), new Set(o.decl ? [`${o.decl.file}:${o.decl.line}`, `${o.decl.file}:${o.decl.nameLine}`] : []), new Map())
+        : [];
+    if (o.decl?.nameless && !o.show.grep)
+        help.unshift(`Run \`ts-axi refs ${o.declaredAt} --grep\` for textual matches of '${word}'`);
     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`);
     help.push(...scopeHelp(o.scope));
     return out(block({
         ...header,
+        ...(o.decl?.nameless ? { note: NAMELESS_NOTE } : {}),
         refs_total: rows.length,
         files,
         tests,
@@ -251,6 +266,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 } : {}),
         ...outside.fields,
         ...scopeFields(o.scope),
         ...footer(semantic, o.started, fileList),
@@ -321,10 +338,11 @@ function renderCallers(semantic, opened, resolved, header, o) {
         help.push(`Run \`ts-axi callers ${o.declaredAt} --depth 2\` for who calls the callers`);
     const outside = rows.length === 0 ? outsideImporters(opened, o) : { fields: {}, help: [] };
     help.unshift(...outside.help);
-    help.push(`Run \`ts-axi refs ${o.declaredAt}\` for every Reference (not only calls)`);
+    help.push(`Run \`ts-axi refs ${o.declaredAt}${o.decl?.nameless ? " --grep" : ""}\` for every Reference (not only calls)`);
     help.push(...scopeHelp(o.scope));
     return out(block({
         ...header,
+        ...(o.decl?.nameless ? { note: NAMELESS_NOTE } : {}),
         refs_total: rows.length,
         files,
         tests,

package/dist/src/impact.js

@@ -1,8 +1,5 @@
-// Pure `impact` logic: changed ranges -> Declarations -> Change classes, ordering
-// and row budgets. No git, no LanguageService: everything here is unit-testable.
-import ts from "typescript";
 import { parseSource } from "./project.js";
-import { collectDeclarations, fullSignatureOf, kindOf } from "./symbols.js";
+import { collectDeclarations } from "./symbols.js";
 const TYPE_LEVEL = new Set(["interface", "type", "enum"]);
 export function matchKey(decl) {
     return `${decl.qualifiedName}#${decl.kind}`;
@@ -64,30 +61,11 @@ export function toRanges(lines) {
 export function formatRanges(ranges) {
     return ranges.map(([a, b]) => (a === b ? String(a) : `${a}-${b}`)).join(" ");
 }
-function nameStart(node, sf) {
-    if (ts.isConstructorDeclaration(node)) {
-        return node.getChildren(sf).find((c) => c.kind === ts.SyntaxKind.ConstructorKeyword)?.getStart(sf) ?? node.getStart(sf);
-    }
-    const name = node.name;
-    return name ? name.getStart(sf) : node.getStart(sf);
-}
 /** Full Signature per match key; overloads are joined so adding one is a `signature` change. */
-export function signatures(sf, decls) {
-    const nodes = new Map();
-    const visit = (node) => {
-        if (kindOf(node) !== undefined) {
-            const at = nameStart(node, sf);
-            // A variable statement starts at `export const`; collectDeclarations keys the declarator name.
-            if (!nodes.has(at))
-                nodes.set(at, node);
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sf);
+export function signatures(decls) {
     const result = new Map();
     for (const decl of decls) {
-        const node = nodes.get(decl.namePos);
-        const text = node ? fullSignatureOf(node, sf) : decl.signature;
+        const text = decl.fullSignature ?? decl.signature;
         const key = matchKey(decl);
         const prev = result.get(key);
         result.set(key, prev === undefined ? text : `${prev}\n${text}`);
@@ -110,8 +88,8 @@ export function classifyFile(input) {
     const beforeMap = beforeSide ? mapRanges(beforeDecls, input.before) : { touched: new Map(), outside: [] };
     const afterByKey = new Map(afterDecls.map((d) => [matchKey(d), d]));
     const beforeByKey = new Map(beforeDecls.map((d) => [matchKey(d), d]));
-    const afterSigs = afterSide ? signatures(afterSide.sf, afterDecls) : new Map();
-    const beforeSigs = beforeSide ? signatures(beforeSide.sf, beforeDecls) : new Map();
+    const afterSigs = afterSide ? signatures(afterDecls) : new Map();
+    const beforeSigs = beforeSide ? signatures(beforeDecls) : new Map();
     const keys = [...new Set([...afterMap.touched.keys(), ...beforeMap.touched.keys()])];
     const changes = [];
     for (const key of keys) {

package/dist/src/symbols.js

@@ -155,6 +155,14 @@ function bodyOf(node) {
 function openBrace(node, sf) {
     return node.getChildren(sf).find((c) => c.kind === ts.SyntaxKind.OpenBraceToken)?.getStart(sf);
 }
+/** Text up to the body of a function initializer, or up to the end of the type annotation (the initializer is the body). */
+function headText(node, sf, init, typeEnd) {
+    if (isFunctionInitializer(init)) {
+        const text = tokenText(node, sf, node.getStart(sf), init.body.getStart(sf));
+        return ts.isArrowFunction(init) ? text.replace(/\s*=>$/, " =>") : text;
+    }
+    return tokenText(node, sf, node.getStart(sf), typeEnd);
+}
 /** Uncapped Signature text; `signatureOf` clips it for display. */
 export function fullSignatureOf(node, sf) {
     if (ts.isVariableDeclaration(node)) {
@@ -163,13 +171,13 @@ export function fullSignatureOf(node, sf) {
         const head = ts.isVariableDeclarationList(list) && ts.isVariableStatement(statement)
             ? tokenText(statement, sf, statement.getStart(sf), list.declarations[0].getStart(sf))
             : "";
-        const fn = isFunctionInitializer(node.initializer) ? node.initializer : undefined;
-        const end = fn ? fn.body.getStart(sf) : node.end;
-        let text = tokenText(node, sf, node.getStart(sf), end);
-        if (fn && ts.isArrowFunction(fn))
-            text = text.replace(/\s*=>$/, " =>");
-        return `${head} ${text}`.trim();
+        return `${head} ${headText(node, sf, node.initializer, (node.type ?? node.exclamationToken ?? node.name).end)}`.trim();
+    }
+    if (ts.isPropertyDeclaration(node)) {
+        return headText(node, sf, node.initializer, (node.type ?? node.exclamationToken ?? node.questionToken ?? node.name).end).replace(/;$/, "");
     }
+    if (ts.isEnumMember(node))
+        return tokenText(node, sf, node.getStart(sf), node.name.end);
     if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
         return tokenText(node, sf, node.getStart(sf), openBrace(node, sf) ?? node.end);
     }
@@ -216,12 +224,76 @@ function nameText(name, sf) {
         return name.text;
     return name.getText(sf);
 }
+/** Registration verbs whose `('Name', fn)` call introduces a nested Declaration (AngularJS style). */
+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"]);
+/** `Template.x.<hook>(fn)` lifecycle callbacks. */
+const TEMPLATE_HOOKS = new Set(["onCreated", "onRendered", "onDestroyed"]);
+function unwrap(expr) {
+    let e = expr;
+    for (;;) {
+        if (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        else if (ts.isPrefixUnaryExpression(e))
+            e = e.operand;
+        else if (ts.isVoidExpression(e))
+            e = e.expression;
+        else
+            return e;
+    }
+}
+function asFunction(expr) {
+    if (!expr)
+        return undefined;
+    const e = unwrap(expr);
+    return ts.isFunctionExpression(e) || ts.isArrowFunction(e) ? e : undefined;
+}
+/** Statements of an IIFE body: `(function () {...})()`, `!function () {...}()`, `(function () {...}).call(this)`. */
+function iifeBody(expr) {
+    if (!expr)
+        return undefined;
+    const call = unwrap(expr);
+    if (!ts.isCallExpression(call))
+        return undefined;
+    let callee = unwrap(call.expression);
+    if (ts.isPropertyAccessExpression(callee) && (callee.name.text === "call" || callee.name.text === "apply"))
+        callee = unwrap(callee.expression);
+    const fn = asFunction(callee);
+    return fn && ts.isBlock(fn.body) ? fn.body.statements : undefined;
+}
+/** The callback of a registration: a function, or the last element of a DI array. */
+function registeredFunction(arg) {
+    if (!arg)
+        return undefined;
+    if (ts.isArrayLiteralExpression(arg))
+        return asFunction(arg.elements[arg.elements.length - 1]);
+    return asFunction(arg);
+}
+function isStringName(node) {
+    return node !== undefined && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node));
+}
+function compact(node, sf) {
+    return node.getText(sf).replace(/\s+/g, "");
+}
+/** Parameter list (and return type) of a function as `(a, b): T`. */
+function paramsText(fn, sf) {
+    const params = fn.parameters.map((p) => tokenText(p, sf, p.getStart(sf), p.end)).join(", ");
+    return `(${params})${fn.type ? `: ${tokenText(fn.type, sf, fn.type.getStart(sf), fn.type.end)}` : ""}`;
+}
+/** `node` text up to the body of its function value; `=>` kept for arrows. */
+function headUntil(node, fn, sf) {
+    const text = tokenText(node, sf, node.getStart(sf), fn.body.getStart(sf));
+    return ts.isArrowFunction(fn) ? text.replace(/\s*=>$/, " =>") : text;
+}
 /**
- * Top-level Declarations of a file in source order, with class, interface and
- * enum members and namespace members following their parent.
+ * Declarations of a file in source order: top-level ones with class, interface
+ * and enum members and namespace members following their parent, plus nested
+ * declarations of script-style code (registrations, IIFE helpers, prototype and
+ * object-literal methods; see GLOSSARY.md Declaration).
  */
 export function collectDeclarations(sf, file) {
-    const result = [];
+    const raws = [];
     const local = localExportNames(sf);
     const add = (node, nameNode, name, exported, parent) => {
         const kind = kindOf(node);
@@ -231,26 +303,228 @@ export function collectDeclarations(sf, file) {
             ? node.parent.parent
             : node;
         const start = startNode.getStart(sf);
-        const startLc = sf.getLineAndCharacterOfPosition(start);
-        const namePos = nameNode ? nameNode.getStart(sf) : start;
         const body = bodyOf(ts.isVariableDeclaration(node) && isFunctionInitializer(node.initializer) ? node.initializer : node);
-        result.push({
-            file,
-            line: startLc.line + 1,
-            col: startLc.character + 1,
-            endLine: sf.getLineAndCharacterOfPosition(node.end).line + 1,
+        raws.push({
+            start,
+            end: node.end,
             kind,
             name,
             qualifiedName: parent ? `${parent}.${name}` : name,
             exported,
-            signature: signatureOf(node, sf),
+            signature: fullSignatureOf(node, sf),
             ...(parent ? { parentName: parent } : {}),
-            namePos,
-            nameLine: sf.getLineAndCharacterOfPosition(namePos).line + 1,
+            namePos: nameNode ? nameNode.getStart(sf) : start,
             hasBody: body !== undefined ||
                 !(ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node)),
         });
     };
+    const nested = (raw) => {
+        raws.push({ ...raw, qualifiedName: raw.qualifiedName ?? (raw.parentName ? `${raw.parentName}.${raw.name}` : raw.name), hasBody: true });
+    };
+    /** Method and function-valued properties of an object literal as `<holder>.<name>`. */
+    const objectMembers = (obj, holder, exported) => {
+        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, signature: fullSignatureOf(prop, sf), namePos: prop.name.getStart(sf) });
+            }
+            else if (ts.isPropertyAssignment(prop)) {
+                const fn = asFunction(prop.initializer);
+                if (fn)
+                    nested({ start: prop.getStart(sf), end: prop.end, kind: "method", name, parentName: holder, exported, signature: headUntil(prop, fn, sf), namePos: prop.name.getStart(sf) });
+            }
+        }
+    };
+    /** `this.x = function` statements at the top level of a constructor-like body. */
+    const thisMembers = (body, owner, exported) => {
+        if (!body || !ts.isBlock(body))
+            return;
+        for (const statement of body.statements) {
+            if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression))
+                continue;
+            const { left, operatorToken, right } = statement.expression;
+            const fn = asFunction(right);
+            if (operatorToken.kind !== ts.SyntaxKind.EqualsToken || !fn || !ts.isPropertyAccessExpression(left) || left.expression.kind !== ts.SyntaxKind.ThisKeyword)
+                continue;
+            nested({ start: statement.getStart(sf), end: statement.end, kind: "method", name: left.name.text, parentName: owner, exported, signature: headUntil(statement.expression, fn, sf), namePos: left.name.getStart(sf) });
+        }
+    };
+    /** Top-level object literals returned by a factory: its API. */
+    const returnedMembers = (body, owner) => {
+        if (ts.isObjectLiteralExpression(unwrap(body)))
+            return objectMembers(unwrap(body), owner, true);
+        if (!ts.isBlock(body))
+            return;
+        for (const statement of body.statements) {
+            if (ts.isReturnStatement(statement) && statement.expression && ts.isObjectLiteralExpression(unwrap(statement.expression))) {
+                objectMembers(unwrap(statement.expression), owner, true);
+            }
+        }
+    };
+    const topLevelExported = (name) => raws.find((r) => r.qualifiedName === name && r.parentName === undefined)?.exported ?? false;
+    const isConstructorName = (name) => /^[A-Z]/.test(name);
+    /** `.controller('Name', fn)` and friends; `.run(fn)` / `.config(fn)` take the verb as name. */
+    const registration = (call, verb) => {
+        const [first, second] = call.arguments;
+        const named = isStringName(first);
+        if (!named && verb !== "run" && verb !== "config")
+            return;
+        const name = named ? first.text : verb;
+        const arg = named ? second : first;
+        const callee = call.expression;
+        const start = named ? first.getStart(sf) : callee.name.getStart(sf);
+        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);
+            return;
+        }
+        const fn = registeredFunction(arg);
+        if (!fn)
+            return;
+        const inject = arg && ts.isArrayLiteralExpression(arg) ? ` [${arg.elements.slice(0, -1).map((e) => e.getText(sf)).join(", ")}]` : "";
+        nested({
+            start,
+            end: arg.end,
+            kind: "function",
+            name,
+            qualifiedName: name,
+            parentName: verb,
+            exported: true,
+            signature: `${verb} ${name}${paramsText(fn, sf)}`,
+            namePos: (ts.isFunctionExpression(fn) && fn.name ? fn.name : fn).getStart(sf),
+            nameless: true,
+        });
+        // The DI array is compared, not displayed: reordering injections is a contract change.
+        if (inject)
+            raws[raws.length - 1].signature += `\n${inject.trim()}`;
+        if (CONSTRUCTOR_VERBS.has(verb))
+            thisMembers(fn.body, name, true);
+        if (verb === "factory" || verb === "service")
+            returnedMembers(fn.body, name);
+    };
+    /** Registrations along a call chain (`angular.module('x').controller(...).service(...)`), in source order. */
+    const callChain = (expr) => {
+        const calls = [];
+        let e = unwrap(expr);
+        while (ts.isCallExpression(e)) {
+            const callee = e.expression;
+            if (ts.isPropertyAccessExpression(callee)) {
+                calls.push({ call: e, name: callee.name.text });
+                e = callee.expression;
+            }
+            else {
+                break;
+            }
+        }
+        for (const { call, name } of calls.reverse()) {
+            const callee = call.expression;
+            const receiver = compact(callee.expression, sf);
+            const first = call.arguments[0];
+            if (receiver === "Meteor" && name === "methods" && first && ts.isObjectLiteralExpression(first)) {
+                objectMembers(first, "methods", true);
+            }
+            else if (receiver.startsWith("Template") && (name === "helpers" || name === "events") && first && ts.isObjectLiteralExpression(first)) {
+                objectMembers(first, `${receiver}.${name}`, true);
+            }
+            else if (receiver.startsWith("Template") && TEMPLATE_HOOKS.has(name) && asFunction(first)) {
+                nested({ start: call.getStart(sf), end: call.end, kind: "method", name, parentName: receiver, exported: true, signature: `${receiver}.${headUntil(first, asFunction(first), sf)}`, namePos: callee.name.getStart(sf) });
+            }
+            else if (REGISTRATION_VERBS.has(name)) {
+                registration(call, name);
+            }
+        }
+    };
+    /** `exports.x = fn`, `module.exports = {...}`, `Foo.prototype.bar = fn`, `Foo.bar = fn`. */
+    const assignment = (statement, expr) => {
+        const left = expr.left;
+        const right = unwrap(expr.right);
+        if (!ts.isPropertyAccessExpression(left))
+            return;
+        const target = compact(left, sf);
+        if (target === "module.exports") {
+            if (ts.isObjectLiteralExpression(right))
+                objectMembers(right, "exports", true);
+            return;
+        }
+        const owner = left.expression;
+        if (ts.isPropertyAccessExpression(owner) && owner.name.text === "prototype" && ts.isIdentifier(owner.expression)) {
+            const cls = owner.expression.text;
+            const fn = asFunction(right);
+            if (fn)
+                nested({ start: statement.getStart(sf), end: statement.end, kind: "method", name: left.name.text, parentName: cls, exported: topLevelExported(cls), signature: headUntil(expr, fn, sf), namePos: left.name.getStart(sf) });
+            return;
+        }
+        if (ts.isIdentifier(left.name) && left.name.text === "prototype" && ts.isIdentifier(owner) && ts.isObjectLiteralExpression(right)) {
+            objectMembers(right, owner.text, topLevelExported(owner.text));
+            return;
+        }
+        const fn = asFunction(right);
+        if (!fn)
+            return;
+        const holder = target === `module.exports.${left.name.text}` ? "exports" : ts.isIdentifier(owner) ? owner.text : undefined;
+        if (holder === undefined)
+            return;
+        const exported = holder === "exports" || topLevelExported(holder);
+        nested({ start: statement.getStart(sf), end: statement.end, kind: "method", name: left.name.text, parentName: holder, exported, signature: headUntil(expr, fn, sf), namePos: left.name.getStart(sf) });
+    };
+    /** Script-style patterns of one module-level statement; `inIife` adds the IIFE's own functions. */
+    const scriptStatement = (statement, inIife) => {
+        if (ts.isFunctionDeclaration(statement)) {
+            if (!statement.name || !statement.body)
+                return;
+            if (inIife)
+                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));
+        }
+        else if (ts.isVariableStatement(statement)) {
+            for (const decl of statement.declarationList.declarations) {
+                if (!ts.isIdentifier(decl.name) || !decl.initializer)
+                    continue;
+                const name = decl.name.text;
+                const fn = asFunction(decl.initializer);
+                if (inIife && fn)
+                    add(decl, decl.name, name, false);
+                const exported = inIife ? false : topLevelExported(name);
+                const init = unwrap(decl.initializer);
+                if (ts.isObjectLiteralExpression(init))
+                    objectMembers(init, name, exported);
+                else if (fn && isConstructorName(name))
+                    thisMembers(fn.body, name, exported);
+                else {
+                    const body = iifeBody(decl.initializer);
+                    if (body)
+                        scriptStatements(body, true);
+                    else
+                        callChain(decl.initializer);
+                }
+            }
+        }
+        else if (ts.isExpressionStatement(statement)) {
+            const expr = unwrap(statement.expression);
+            const body = iifeBody(expr);
+            if (body)
+                scriptStatements(body, true);
+            else if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+                assignment(statement, expr);
+            else
+                callChain(expr);
+        }
+        else if (ts.isIfStatement(statement)) {
+            scriptStatement(statement.thenStatement, inIife);
+            if (statement.elseStatement)
+                scriptStatement(statement.elseStatement, inIife);
+        }
+        else if (ts.isBlock(statement)) {
+            scriptStatements(statement.statements, inIife);
+        }
+    };
+    const scriptStatements = (statements, inIife) => {
+        for (const statement of statements)
+            scriptStatement(statement, inIife);
+    };
     const visitStatements = (statements, parent, parentExported) => {
         for (const statement of statements) {
             if (ts.isVariableStatement(statement)) {
@@ -260,6 +534,8 @@ export function collectDeclarations(sf, file) {
                     const exported = parent ? parentExported && hasModifier(statement, ts.SyntaxKind.ExportKeyword) : isTopLevelExported(statement, decl.name.text, local);
                     add(decl, decl.name, decl.name.text, exported, parent);
                 }
+                if (!parent)
+                    scriptStatement(statement, false);
                 continue;
             }
             if (ts.isFunctionDeclaration(statement) ||
@@ -307,11 +583,39 @@ export function collectDeclarations(sf, file) {
                 else if (ts.isModuleDeclaration(statement) && statement.body && ts.isModuleBlock(statement.body)) {
                     visitStatements(statement.body.statements, qualified, exported);
                 }
+                else if (ts.isFunctionDeclaration(statement) && !parent) {
+                    scriptStatement(statement, false);
+                }
+                continue;
             }
+            if (!parent)
+                scriptStatement(statement, false);
         }
     };
     visitStatements(sf.statements, undefined, true);
-    return result;
+    // Nested declarations are found after their holder statement; source order is start order.
+    const ordered = raws.map((r, i) => ({ r, i })).sort((a, b) => a.r.start - b.r.start || a.i - b.i);
+    return ordered.map(({ r }) => {
+        const startLc = sf.getLineAndCharacterOfPosition(r.start);
+        const full = r.signature;
+        return {
+            file,
+            line: startLc.line + 1,
+            col: startLc.character + 1,
+            endLine: sf.getLineAndCharacterOfPosition(r.end).line + 1,
+            kind: r.kind,
+            name: r.name,
+            qualifiedName: r.qualifiedName,
+            exported: r.exported,
+            signature: clip(full.split("\n")[0]),
+            ...(r.parentName !== undefined ? { parentName: r.parentName } : {}),
+            namePos: r.namePos,
+            nameLine: sf.getLineAndCharacterOfPosition(r.namePos).line + 1,
+            hasBody: r.hasBody,
+            fullSignature: full,
+            ...(r.nameless ? { nameless: true } : {}),
+        };
+    });
 }
 /** Declarations sharing file and qualified name (overloads, merging) are one Symbol. */
 export function symbolKey(decl) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-axi",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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": [