ast-mcp-server 0.15.0 → 0.16.0

package/dist/services/angular-template-scope.js

@@ -0,0 +1,163 @@
+import { Node, SyntaxKind } from "ts-morph";
+import { componentDecorator, isAngularCoreExport, isCoreDecorator } from "./angular-decorators.js";
+export const MAX_SCOPE_VISITS = 10_000;
+export const MAX_SCOPE_DEPTH = 32;
+export class ScopeWorkExhausted extends Error {
+}
+/** Follows aliases to the declarations a node refers to. */
+function declarationsOf(node) {
+    const symbol = node.getSymbol();
+    const resolved = symbol?.isAlias() ? (symbol.getAliasedSymbol() ?? symbol) : symbol;
+    return resolved?.getDeclarations() ?? [];
+}
+const isExternal = (declaration) => declaration.getSourceFile().isFromExternalLibrary();
+function ngModuleMetadata(cls) {
+    const decorator = cls.getDecorators().find((candidate) => isCoreDecorator(candidate, "NgModule"));
+    if (!decorator)
+        return undefined;
+    const metadata = decorator.getArguments()[0];
+    return Node.isObjectLiteralExpression(metadata) ? metadata : "opaque";
+}
+/** Elements of a metadata array: none when the key is absent, `opaque` when not an array literal. */
+function listOf(metadata, key) {
+    const property = metadata.getProperty(key);
+    if (!property)
+        return [];
+    const list = Node.isPropertyAssignment(property) ? property.getInitializer() : undefined;
+    return Node.isArrayLiteralExpression(list) ? list.getElements() : "opaque";
+}
+function merge(results) {
+    if (results.includes("target"))
+        return "target";
+    return results.includes("opaque") ? "opaque" : "other";
+}
+/**
+ * Resolves, with ts-morph only, whether the target is in a consumer's scope. Memoized per
+ * request. Anything that cannot be proven is `opaque`; the caller decides what that costs.
+ */
+export function createScopeResolver(target, options) {
+    const memo = new Map();
+    const tick = () => {
+        if (--options.budget.scopeVisits < 0)
+            throw new ScopeWorkExhausted();
+        options.rc.checkpoint();
+    };
+    const referenceOf = (expression) => {
+        tick();
+        if (Node.isCallExpression(expression)) {
+            const callee = expression.getExpression();
+            const [arrow] = expression.getArguments();
+            if (isAngularCoreExport(callee, "forwardRef")) {
+                return Node.isArrowFunction(arrow) && !Node.isBlock(arrow.getBody())
+                    ? referenceOf(arrow.getBody())
+                    : "opaque";
+            }
+            let root = callee;
+            while (Node.isPropertyAccessExpression(root))
+                root = root.getExpression();
+            // A library cannot export project classes, so its calls never add the target.
+            const declarations = Node.isIdentifier(root) ? declarationsOf(root) : [];
+            return declarations.length > 0 && declarations.every(isExternal) ? "external" : "opaque";
+        }
+        if (!Node.isIdentifier(expression))
+            return "opaque";
+        const declarations = declarationsOf(expression);
+        const [declaration] = declarations;
+        if (declarations.length !== 1 || !Node.isClassDeclaration(declaration))
+            return "opaque";
+        return isExternal(declaration) ? "external" : declaration;
+    };
+    /** What an element of `imports` / `exports` makes visible: itself, or a module's exports. */
+    const contribution = (expression, trail, depth) => {
+        const reference = referenceOf(expression);
+        if (reference === "external")
+            return "other";
+        if (reference === "opaque")
+            return "opaque";
+        if (reference === target)
+            return "target";
+        const metadata = ngModuleMetadata(reference);
+        if (!metadata)
+            return "other";
+        if (trail.has(reference))
+            return "other";
+        if (depth > MAX_SCOPE_DEPTH || metadata === "opaque")
+            return "opaque";
+        if (reference.getSourceFile().isDeclarationFile())
+            return "opaque";
+        trail.add(reference);
+        const exported = listOf(metadata, "exports");
+        if (exported === "opaque")
+            return "opaque";
+        return merge(exported.map((element) => contribution(element, trail, depth + 1)));
+    };
+    const scopeOf = (imports, trail) => merge(imports.map((element) => contribution(element, trail, 1)));
+    const verdictOf = (found) => found === "target" ? "includes" : found === "opaque" ? "opaque" : "excludes";
+    let declaring;
+    /** Every project NgModule with the classes it declares; built once, on first module consumer. */
+    const declaringModules = () => {
+        if (declaring)
+            return declaring;
+        declaring = { modules: [], opaque: false };
+        const classes = target
+            .getProject()
+            .getSourceFiles()
+            .filter((file) => !file.isDeclarationFile() &&
+            !file.isFromExternalLibrary() &&
+            file.getFullText().includes("NgModule"))
+            .flatMap((file) => file.getDescendantsOfKind(SyntaxKind.ClassDeclaration));
+        for (const cls of classes) {
+            const metadata = ngModuleMetadata(cls);
+            if (!metadata)
+                continue;
+            const list = metadata === "opaque" ? "opaque" : listOf(metadata, "declarations");
+            const references = list === "opaque" ? [] : list.map(referenceOf);
+            if (metadata === "opaque" || list === "opaque" || references.includes("opaque")) {
+                declaring.opaque = true;
+                continue;
+            }
+            declaring.modules.push({
+                metadata,
+                declared: new Set(references.filter((reference) => typeof reference !== "string")),
+            });
+        }
+        return declaring;
+    };
+    const resolve = (consumer) => {
+        if (consumer === target)
+            return "includes";
+        const metadata = componentDecorator(consumer)?.getArguments()[0];
+        if (!Node.isObjectLiteralExpression(metadata))
+            return "opaque";
+        const flag = metadata.getProperty("standalone");
+        const initializer = Node.isPropertyAssignment(flag) ? flag.getInitializer() : undefined;
+        if (flag && !Node.isTrueLiteral(initializer) && !Node.isFalseLiteral(initializer)) {
+            return "opaque";
+        }
+        const standalone = flag
+            ? Node.isTrueLiteral(initializer)
+            : options.coreMajor !== undefined && options.coreMajor >= 19;
+        const trail = new Set();
+        if (!standalone) {
+            if (!flag && options.coreMajor === undefined)
+                return "opaque";
+            const { modules, opaque } = declaringModules();
+            const owners = modules.filter((module) => module.declared.has(consumer));
+            if (opaque || owners.length !== 1)
+                return "opaque";
+            const [owner] = owners;
+            if (owner.declared.has(target))
+                return "includes";
+            const imports = listOf(owner.metadata, "imports");
+            return imports === "opaque" ? "opaque" : verdictOf(scopeOf(imports, trail));
+        }
+        const imports = listOf(metadata, "imports");
+        return imports === "opaque" ? "opaque" : verdictOf(scopeOf(imports, trail));
+    };
+    return (consumer) => {
+        let verdict = memo.get(consumer);
+        if (!verdict)
+            memo.set(consumer, (verdict = resolve(consumer)));
+        return verdict;
+    };
+}

package/dist/services/angular-templates.js

@@ -5,14 +5,18 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { Node, SyntaxKind } from "ts-morph";
+import { angularCoreMajor, componentDecorator, isCoreDecorator, isDirectiveClass, isMetadataPublic, isPipeClass, isSelectorPublic, literalString, bindingNames, metadataBindingNames, } from "./angular-decorators.js";
+import { extractConsumerUsages, mayMatch, } from "./angular-template-bindings.js";
+import { createScopeResolver, MAX_SCOPE_VISITS, ScopeWorkExhausted, } from "./angular-template-scope.js";
 import { assertSafeOperationFile } from "./safe-file.js";
 const MAX_TEMPLATE_BYTES = 512 * 1024;
 const MAX_TEMPLATE_NODES = 100_000;
 const CHECKPOINT_EVERY_NODES = 1000;
-const MIN_COMPILER_MAJOR = 20;
+const MIN_COMPILER_MAJOR = 18;
 const MAX_COMPILER_MAJOR = 22;
 const TWO_WAY_BINDING = 5; // BindingType.TwoWay, stable across supported majors
 const TWO_WAY_EVENT = 2; // ParsedEventType.TwoWay, stable across supported majors
+const SCAN_LIMITS = { templates: 2000, bytes: 32 * 1024 * 1024, nodes: 1_000_000 };
 const NOT_APPLICABLE = { coverage: { status: "not_applicable" }, usages: [] };
 const ASSIGNMENT_OPERATION = /^(?:=|(?:\*\*|&&|\|\||\?\?|<<|>>>|>>|[+\-*/%&|^])=)$/u;
 const compilerCache = new Map();
@@ -92,7 +96,12 @@ async function loadCompiler(tsConfigFilePath) {
                 compiler.PropertyRead,
                 compiler.Call,
             ].every((member) => typeof member === "function");
-        return complete ? { compiler } : unsupported;
+        const selectors = [
+            compiler.CssSelector?.parse,
+            compiler.SelectorMatcher,
+            compiler.createCssSelectorFromNode,
+        ].every((member) => typeof member === "function");
+        return complete ? { compiler, selectors } : unsupported;
     }
     catch {
         return unsupported;
@@ -101,29 +110,6 @@ async function loadCompiler(tsConfigFilePath) {
 function hasAngularCore(context) {
     return resolveFrom(context.tsConfigFilePath, "@angular/core/package.json") !== undefined;
 }
-function isComponentDecorator(decorator) {
-    const callee = decorator.getCallExpression()?.getExpression();
-    if (!callee)
-        return false;
-    return decorator
-        .getSourceFile()
-        .getImportDeclarations()
-        .filter((declaration) => declaration.getModuleSpecifierValue() === "@angular/core")
-        .some((declaration) => {
-        const namespace = declaration.getNamespaceImport();
-        if (Node.isPropertyAccessExpression(callee)) {
-            return (callee.getName() === "Component" &&
-                callee.getExpression().getText() === namespace?.getText());
-        }
-        return declaration
-            .getNamedImports()
-            .some((specifier) => specifier.getName() === "Component" &&
-            (specifier.getAliasNode()?.getText() ?? "Component") === callee.getText());
-    });
-}
-function componentDecorator(cls) {
-    return cls.getDecorators().find(isComponentDecorator);
-}
 /** Finds the template of a component class from literal metadata only. */
 function locateTemplate(cls) {
     const unresolved = { reason: "template_unresolved" };
@@ -201,7 +187,7 @@ export function listTemplateFiles(context) {
     }
     return [...files].sort();
 }
-function memberOwner(node) {
+export function memberOwner(node) {
     let owner;
     if (Node.isParameterDeclaration(node)) {
         owner = node.isParameterProperty() ? node.getParent()?.getParent() : undefined;
@@ -232,8 +218,12 @@ function hasDerivedComponent(context, cls) {
 }
 class WorkExhausted extends Error {
 }
+/** A pipe name span that does not slice to the name: the usage cannot be edited exactly. */
+class SpanDrift extends Error {
+}
 /** Walks parsed template nodes with a scope stack so template-local names shadow members. */
-function extractUsages(compiler, nodes, memberName, rc) {
+function extractUsages(compiler, nodes, query, rc, onNode = () => { }) {
+    const memberName = "member" in query ? query.member : undefined;
     const usages = new Map();
     const scopes = [];
     let visited = 0;
@@ -242,6 +232,7 @@ function extractUsages(compiler, nodes, memberName, rc) {
             throw new WorkExhausted();
         if (visited % CHECKPOINT_EVERY_NODES === 0)
             rc.checkpoint();
+        onNode();
     };
     const isLocal = (name) => scopes.some((scope) => scope.has(name));
     const record = (ast, kind) => {
@@ -251,13 +242,15 @@ function extractUsages(compiler, nodes, memberName, rc) {
             start: ast.nameSpan.start,
             end: ast.nameSpan.end,
             kind: merged,
+            role: "own",
             localsInScope: [...new Set(scopes.flatMap((scope) => [...scope]))].sort(),
         });
     };
     // Explicit `this.` bypasses template locals; ThisReceiver only extends ImplicitReceiver in some majors.
     const isMemberReceiver = (receiver) => receiver instanceof compiler.ThisReceiver ||
         (receiver instanceof compiler.ImplicitReceiver && !isLocal(memberName));
-    const isMember = (ast) => ast instanceof compiler.PropertyRead &&
+    const isMember = (ast) => memberName !== undefined &&
+        ast instanceof compiler.PropertyRead &&
         ast.name === memberName &&
         isMemberReceiver(ast.receiver);
     class Expressions extends compiler.RecursiveAstVisitor {
@@ -287,6 +280,15 @@ function extractUsages(compiler, nodes, memberName, rc) {
             record(ast.left, "TemplatePropertyWrite");
             this.visit(ast.right, context);
         }
+        visitPipe(ast, context) {
+            if ("pipe" in query && ast.name === query.pipe) {
+                if (query.text.slice(ast.nameSpan.start, ast.nameSpan.end) !== query.pipe) {
+                    throw new SpanDrift();
+                }
+                record(ast, "TemplatePipeName");
+            }
+            super.visitPipe(ast, context);
+        }
         visitPropertyWrite(ast, context) {
             if (ast.name === memberName && isMemberReceiver(ast.receiver)) {
                 record(ast, "TemplatePropertyWrite");
@@ -429,81 +431,274 @@ function decodeTemplate(bytes) {
         return undefined;
     }
 }
-/** Collects usages of a component member inside its declaring component's template. */
-export async function collectTemplateUsages(node, context, rc) {
-    rc.checkpoint();
-    const owner = memberOwner(node);
-    if (!owner || !hasAngularCore(context))
-        return NOT_APPLICABLE;
-    const isComponent = componentDecorator(owner.cls) !== undefined;
-    const derived = hasDerivedComponent(context, owner.cls);
-    if (!isComponent && !derived)
-        return NOT_APPLICABLE;
-    const fail = (status, reason) => ({
-        coverage: { status, reason, templates: 0 },
-        usages: [],
-    });
-    if (derived)
-        return fail("unsupported", "inherited_member");
-    const loaded = await loadCompiler(context.tsConfigFilePath);
-    if ("reason" in loaded)
-        return fail("unfinished", loaded.reason);
-    const located = locateTemplate(owner.cls);
-    if ("reason" in located)
-        return fail("unfinished", located.reason);
+/** Reads a located template within the per-template size cap. */
+async function readTemplate(context, located) {
     let text;
-    let offset = 0;
     let bytes;
     if (located.container === "inline") {
-        ({ text, offset } = located);
+        text = located.text;
         bytes = Buffer.from(text, "utf8");
     }
     else {
         const unsafe = checkTemplatePath(context.projectRoot, located.absolutePath);
         if (unsafe)
-            return fail("unfinished", unsafe);
+            return { reason: unsafe };
         if ((await stat(located.absolutePath)).size > MAX_TEMPLATE_BYTES) {
-            return fail("unfinished", "size_exceeded");
+            return { reason: "size_exceeded" };
         }
         bytes = await readFile(located.absolutePath);
         const decoded = decodeTemplate(bytes);
         if (decoded === undefined)
-            return fail("unfinished", "template_parse_error");
+            return { reason: "template_parse_error" };
         text = decoded;
     }
     // Shared cap: the external path also checks the size before reading, inline checks here.
     if (bytes.length > MAX_TEMPLATE_BYTES)
-        return fail("unfinished", "size_exceeded");
+        return { reason: "size_exceeded" };
+    return { text, bytes, offset: located.container === "inline" ? located.offset : 0 };
+}
+function toUsages(context, cls, located, read, raw) {
+    const fileText = located.container === "inline" ? cls.getSourceFile().getFullText() : read.text;
+    const fileHash = createHash("sha256").update(read.bytes).digest("hex");
+    return raw.map((usage) => {
+        const start = usage.start + read.offset;
+        return {
+            ...usage,
+            absolutePath: located.absolutePath,
+            file: path.relative(context.projectRoot, located.absolutePath),
+            container: located.container,
+            start,
+            end: usage.end + read.offset,
+            ...lineColumn(fileText, start),
+            fileHash,
+        };
+    });
+}
+/** Selector and public binding names, or undefined when bindings cannot be named from the member. */
+function bindingTarget(cls, node, name) {
+    const metadata = componentDecorator(cls)?.getArguments()[0];
+    if (!Node.isObjectLiteralExpression(metadata) || metadata.getProperty("hostDirectives")) {
+        return undefined;
+    }
+    const property = metadata.getProperty("selector");
+    const selector = literalString(Node.isPropertyAssignment(property) ? property.getInitializer() : undefined);
+    const names = isMetadataPublic(cls, name)
+        ? // A member both decorated and listed in metadata has ambiguous binding names.
+            isSelectorPublic(node)
+                ? undefined
+                : metadataBindingNames(cls, name)
+        : bindingNames(node, name);
+    if (!selector || !names)
+        return undefined;
+    return { selector, inputs: names.inputs, outputs: names.outputs };
+}
+/** Parses a consumer template, or returns undefined when the compiler reports errors. */
+function parseConsumer(compiler, text, absolutePath) {
+    const parsed = compiler.parseTemplate(text, absolutePath, { preserveWhitespaces: true });
+    return parsed.errors?.length ? undefined : parsed.nodes;
+}
+function selectorInspector(compiler, target) {
+    return (text, absolutePath, tick) => {
+        if (!mayMatch(compiler, target.selector, text))
+            return "skip";
+        const nodes = parseConsumer(compiler, text, absolutePath);
+        if (!nodes)
+            return "template_parse_error";
+        const scan = extractConsumerUsages(compiler, nodes, text, target, tick);
+        const usages = scan.usages.map((usage) => ({
+            ...usage,
+            localsInScope: [],
+            role: "consumer",
+        }));
+        return { matched: scan.matched, opaque: scan.opaque, usages };
+    };
+}
+function pipeInspector(compiler, name, rc) {
+    return (text, absolutePath, tick) => {
+        if (!text.includes(name))
+            return "skip";
+        const nodes = parseConsumer(compiler, text, absolutePath);
+        if (!nodes)
+            return "template_parse_error";
+        try {
+            const raw = extractUsages(compiler, nodes, { pipe: name, text }, rc, tick);
+            const usages = raw.map((usage) => ({ ...usage, role: "consumer" }));
+            return { matched: usages.length > 0, opaque: false, usages };
+        }
+        catch (error) {
+            if (error instanceof SpanDrift)
+                return { matched: true, opaque: true, usages: [] };
+            throw error;
+        }
+    };
+}
+/**
+ * Scans every component template in the Project with `inspect`. Matching comes first; scope only
+ * filters matches. Unreadable templates and unproven scopes are reported.
+ */
+async function scanConsumers(context, cls, inspect, rc, limits) {
+    const remaining = { ...SCAN_LIMITS, ...limits };
+    const usages = [];
+    let failure;
+    let examined = 0;
+    const resolve = createScopeResolver(cls, {
+        coreMajor: angularCoreMajor(context),
+        budget: { scopeVisits: MAX_SCOPE_VISITS },
+        rc,
+    });
+    const tick = () => {
+        if (--remaining.nodes < 0)
+            throw new WorkExhausted();
+        if (remaining.nodes % CHECKPOINT_EVERY_NODES === 0)
+            rc.checkpoint();
+    };
+    try {
+        for (const consumer of componentClasses(context)) {
+            rc.checkpoint();
+            if (--remaining.templates < 0)
+                throw new WorkExhausted();
+            const located = locateTemplate(consumer);
+            if ("reason" in located) {
+                failure ??= located.reason;
+                continue;
+            }
+            const read = await readTemplate(context, located);
+            if ("reason" in read) {
+                failure ??= read.reason;
+                continue;
+            }
+            remaining.bytes -= read.bytes.length;
+            if (remaining.bytes < 0)
+                throw new WorkExhausted();
+            examined += 1;
+            const scan = inspect(read.text, located.absolutePath, tick);
+            if (scan === "skip")
+                continue;
+            if (scan === "template_parse_error") {
+                failure ??= scan;
+                continue;
+            }
+            if (scan.opaque)
+                failure ??= "cross_component";
+            if (!scan.matched)
+                continue;
+            const verdict = resolve(consumer);
+            if (verdict === "opaque")
+                failure ??= "cross_component";
+            if (verdict === "includes") {
+                usages.push(...toUsages(context, consumer, located, read, scan.usages));
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof WorkExhausted || error instanceof ScopeWorkExhausted) {
+            return { usages: [], failure: "work_exhausted", examined };
+        }
+        throw error;
+    }
+    return { usages, failure, examined };
+}
+/** The literal `name` of a `@Pipe({ name })` class, or undefined when it is not a plain literal. */
+function pipeName(cls) {
+    const decorator = cls.getDecorators().find((candidate) => isCoreDecorator(candidate, "Pipe"));
+    const metadata = decorator?.getArguments()[0];
+    if (!Node.isObjectLiteralExpression(metadata))
+        return undefined;
+    const property = metadata.getProperty("name");
+    return literalString(Node.isPropertyAssignment(property) ? property.getInitializer() : undefined);
+}
+/** `| name` usages of a pipe class in the templates of components that have the class in scope. */
+async function collectPipeUsages(cls, context, rc, limits) {
+    const unfinished = (reason, templates = 0) => ({
+        coverage: { status: "unfinished", reason, templates },
+        usages: [],
+    });
+    const name = pipeName(cls);
+    if (name === undefined)
+        return unfinished("cross_component");
+    const loaded = await loadCompiler(context.tsConfigFilePath);
+    if ("reason" in loaded)
+        return unfinished(loaded.reason);
+    const scan = await scanConsumers(context, cls, pipeInspector(loaded.compiler, name, rc), rc, limits);
+    const coverage = scan.failure
+        ? { status: "unfinished", reason: scan.failure, templates: scan.examined }
+        : { status: "completed", templates: scan.examined };
+    return { coverage, usages: scan.usages };
+}
+/** Collects usages of a component member inside its declaring component's template. */
+export async function collectTemplateUsages(node, context, rc, limits = {}) {
+    rc.checkpoint();
+    if (!hasAngularCore(context))
+        return NOT_APPLICABLE;
+    const fail = (status, reason) => ({
+        coverage: { status, reason, templates: 0 },
+        usages: [],
+    });
+    if (Node.isClassDeclaration(node)) {
+        return isPipeClass(node) ? collectPipeUsages(node, context, rc, limits) : NOT_APPLICABLE;
+    }
+    const owner = memberOwner(node);
+    if (!owner)
+        return NOT_APPLICABLE;
+    if (isPipeClass(owner.cls)) {
+        // Only `transform` is the pipe contract: it reports the pipe's usages but a rename stays refused.
+        if (owner.name !== "transform" || componentDecorator(owner.cls)) {
+            return fail("unfinished", "cross_component");
+        }
+        return { ...(await collectPipeUsages(owner.cls, context, rc, limits)), renameBlocked: true };
+    }
+    const isComponent = componentDecorator(owner.cls) !== undefined;
+    const selectorPublic = isSelectorPublic(node) || isMetadataPublic(owner.cls, owner.name);
+    if (!isComponent && selectorPublic && isDirectiveClass(owner.cls)) {
+        return fail("unfinished", "cross_component");
+    }
+    const derived = hasDerivedComponent(context, owner.cls);
+    if (!isComponent && !derived)
+        return NOT_APPLICABLE;
+    if (derived)
+        return fail("unsupported", "inherited_member");
+    const loaded = await loadCompiler(context.tsConfigFilePath);
+    if ("reason" in loaded)
+        return fail("unfinished", loaded.reason);
+    const located = locateTemplate(owner.cls);
+    if ("reason" in located)
+        return fail("unfinished", located.reason);
+    const read = await readTemplate(context, located);
+    if ("reason" in read)
+        return fail("unfinished", read.reason);
     rc.checkpoint();
-    const parsed = loaded.compiler.parseTemplate(text, located.absolutePath, {
+    const parsed = loaded.compiler.parseTemplate(read.text, located.absolutePath, {
         preserveWhitespaces: true,
     });
     if (parsed.errors?.length)
         return fail("unfinished", "template_parse_error");
     let raw;
     try {
-        raw = extractUsages(loaded.compiler, parsed.nodes, owner.name, rc);
+        raw = extractUsages(loaded.compiler, parsed.nodes, { member: owner.name }, rc);
     }
     catch (error) {
         if (error instanceof WorkExhausted)
             return fail("unfinished", "work_exhausted");
         throw error;
     }
-    const fileText = located.container === "inline" ? owner.cls.getSourceFile().getFullText() : text;
-    const fileHash = createHash("sha256").update(bytes).digest("hex");
-    const usages = raw.map((usage) => {
-        const start = usage.start + offset;
-        return {
-            absolutePath: located.absolutePath,
-            file: path.relative(context.projectRoot, located.absolutePath),
-            container: located.container,
-            start,
-            end: usage.end + offset,
-            ...lineColumn(fileText, start),
-            kind: usage.kind,
-            localsInScope: usage.localsInScope,
-            fileHash,
-        };
+    const usages = toUsages(context, owner.cls, located, read, raw);
+    if (!selectorPublic)
+        return { coverage: { status: "completed", templates: 1 }, usages };
+    // Selector-public members are also bound in consuming templates: scan every component template.
+    const target = bindingTarget(owner.cls, node, owner.name);
+    const unfinished = (reason, templates = 1) => ({
+        coverage: { status: "unfinished", reason, templates },
+        usages,
     });
-    return { coverage: { status: "completed", templates: 1 }, usages };
+    if (!target)
+        return unfinished("cross_component");
+    if (!loaded.selectors)
+        return unfinished("compiler_unsupported");
+    const scan = await scanConsumers(context, owner.cls, selectorInspector(loaded.compiler, target), rc, limits);
+    const coverage = scan.failure
+        ? { status: "unfinished", reason: scan.failure, templates: scan.examined }
+        : { status: "completed", templates: scan.examined };
+    // Names listed in `inputs` / `outputs` metadata are strings that a TypeScript rename cannot follow.
+    const renameBlocked = isMetadataPublic(owner.cls, owner.name);
+    return { coverage, usages: [...usages, ...scan.usages], renameBlocked };
 }

package/dist/services/operations.js

@@ -4,6 +4,8 @@ import { open, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { createTwoFilesPatch } from "diff";
 import { LanguageVariant, Node, ScriptTarget, SyntaxKind, ts } from "ts-morph";
+import { isPipeClass } from "./angular-decorators.js";
+import { planTemplateEdits } from "./angular-template-rename.js";
 import { collectTemplateUsages } from "./angular-templates.js";
 import { findNonDeclarationReferences } from "./references.js";
 import { compareObservedDiagnostics, observeDiagnostic, } from "./diagnostics.js";
@@ -390,8 +392,8 @@ function publicOperation(record) {
 }
 const TEMPLATE_ANY_CAST = "$any";
 /** Fails closed before any edit when template evidence is incomplete or the new name would be captured. */
-function assertTemplateRenameAllowed(coverageStatus, usages, newName) {
-    if (coverageStatus === "unfinished" || coverageStatus === "unsupported") {
+function assertTemplateRenameAllowed(coverageStatus, usages, newName, renameBlocked = false) {
+    if (renameBlocked || coverageStatus === "unfinished" || coverageStatus === "unsupported") {
         throw new PublicOperationalError("INCOMPLETE_EVIDENCE", "Template coverage is incomplete, so the rename cannot be proven safe.");
     }
     if (usages.some((usage) => usage.container === "inline")) {
@@ -417,20 +419,32 @@ export async function prepareRename(args, requestContext = NO_REQUEST_CONTEXT) {
         if (!Node.isRenameable(node)) {
             throw new Error(`Symbol "${args.symbolPath}" (${node.getKindName()}) does not support structural rename.`);
         }
+        // Templates bind a pipe by its `name` literal, never by class, so a class rename has no
+        // template edit and needs no template evidence.
+        const pipeClass = Node.isClassDeclaration(node) && isPipeClass(node);
         // Template usages must be collected before the rename mutates the program.
-        const { coverage, usages } = await collectTemplateUsages(node, context, rc);
-        assertTemplateRenameAllowed(coverage.status, usages, args.newName);
+        const { coverage, usages, renameBlocked } = pipeClass
+            ? {
+                coverage: { status: "not_applicable" },
+                usages: [],
+                renameBlocked: false,
+            }
+            : await collectTemplateUsages(node, context, rc);
+        assertTemplateRenameAllowed(coverage.status, usages, args.newName, renameBlocked);
+        const edits = coverage.status === "completed" || usages.length > 0
+            ? planTemplateEdits(node, usages, args.newName, context)
+            : [];
         const tsReferenceCount = Node.isReferenceFindable(node)
             ? findNonDeclarationReferences(node).length
             : 0;
         node.rename(args.newName);
         return {
-            referenceCount: tsReferenceCount + usages.length,
-            auxiliaryEdits: usages.map((usage) => ({
+            referenceCount: tsReferenceCount + edits.length,
+            auxiliaryEdits: edits.map(({ usage, newText }) => ({
                 absolutePath: usage.absolutePath,
                 start: usage.start,
                 end: usage.end,
-                newText: args.newName,
+                newText,
                 expectedHash: usage.fileHash,
             })),
         };