ast-mcp-server 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -6,7 +6,41 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
-## [0.15.0] — not yet published (2026-11-04)
+## [0.16.0] — not yet published (2026-11-06)
+
+### Added
+
+- `ast_find_references` lists the binding usages of a selector-public member (`@Input`, `@Output`, `input()`, `output()` without aliases) in the templates of consuming components whose literal `imports` include the declaring standalone component, and reports `completed` only when every component template in the Project was read and every match resolved; otherwise `unfinished` with `cross_component`, `work_exhausted` or the template's own reason. (#408).
+- Consumer template usages are also resolved through NgModules: a consumer declared in exactly one module with literal `declarations` sees that module's declarations plus the `exports` of its `imports`, followed through re-exported modules, and a standalone consumer importing a module sees its `exports`. When the `standalone` flag is absent, `@angular/core` 18 treats the consumer as module-declared and 19 or later as standalone. Spreads, variables, project calls such as `forRoot()`, a consumer declared in several modules or in none, and chains deeper than 32 modules stay `unfinished` with `cross_component` (#408).
+- Consumer template usages follow literal aliases (`@Input('a')`, `@Input({ alias: 'a' })`, `input(x, { alias: 'a' })`, `output({ alias: 'a' })`), `model()` and `model.required()` (a two-way `[(x)]`, `[x]` and `(xChange)`, or the alias and `aliasChange`), and members listed in literal `inputs` / `outputs` metadata (`'x'`, `'x: alias'`, `{ name, alias }`). A non-literal alias or metadata entry stays `unfinished` with `cross_component` (#408).
+- `ast_find_references` lists `| name` usages (kind `TemplatePipeName`) of a `@Pipe` class with a literal `name` and of its `transform` member, in the templates of components whose resolved scope (standalone or NgModule) contains the pipe class. A pipe with the same name outside that scope is ignored; a non-literal `name`, an opaque consumer scope that could see the pipe, or an unreadable template stays `unfinished`. `ast_rename_symbol` now renames a `@Pipe` class with TypeScript edits only (the `name` literal and every `| name` usage stay), while renaming `transform` stays refused with `INCOMPLETE_EVIDENCE` (#408).
+- `ast_rename_symbol` now renames a selector-public member (`@Input`, `@Output`, `input()`, `output()`, `model()`) together with its consumer bindings when coverage is `completed`: each external consumer template gets a per-usage rewrite that keeps `[` `(` `[(` `bind-` `on-` `bindon-` and the values, a `model()` event key becomes `<name>Change`, and alias-keyed bindings stay. Consumer `.html` files are listed in `affected_files`, bound by hash and rolled back like the member's own template. It returns `MUTATION_BLOCKED` before any write for an inline consumer template, `[(x)]` on a non-`model()` pair, a new name that duplicates another input, output or alias of the directive (or its derived `Change` name) or is bound by another directive matched on the same element, `$any`, or a name in the directive's own selector. Opaque scopes, `hostDirectives`, `@Directive` members, non-literal aliases, members listed in `inputs` / `outputs` metadata and pipe `transform` stay `INCOMPLETE_EVIDENCE`. Diagnostics remain TypeScript-only, so run the project's build or tests afterwards (#408).
+
+### Changed
+
+- The `ast_find_references` and `ast_rename_symbol` descriptions now state the cross-component contract: `ast_find_references` template usages include consumer templates and `completed` covers templates inside the Project only, and `ast_rename_symbol` also rewrites consumer templates when coverage is `completed`. Input and output schemas are unchanged. Both descriptions are re-declared in `test/fixtures/declared-tool-contracts.json`, and the tool-inventory, registry-consumer and canary digests were re-baselined. The structural-code-editing skill, its operations reference and the README document consumer usages, the constructs that stay `unfinished` or are never examined (`setInput`, router input binding, `createComponent`, `hostDirectives`, `@Directive` inputs and outputs, consumers outside the Project), the `@Pipe` class and `transform` rename rules, and that diagnostics stay TypeScript-only, with template type checking of rename plans tracked in #421 (#408).
+
+### Fixed
+
+- Selector-public component members (`@Input`, `@Output`, `input()`, `output()`, `model()`) and `@Pipe` classes reported `template_coverage: completed` (pipes reported nothing), and a rename of an `@Input` was planned without blocking although the consuming templates were never read. They now report `unfinished` with the new reason `cross_component` (own-template usages are still listed for inputs and outputs), and `ast_rename_symbol` refuses them with `INCOMPLETE_EVIDENCE` (#407).
+- `@Directive` members declared with `@Input`, `@Output`, `input()`, `output()` or `model()` reported no `template_coverage`, and members listed in the `inputs` / `outputs` metadata arrays of a `@Component` or `@Directive` were treated as plain members, so `ast_rename_symbol` planned their rename without blocking. They now report `unfinished` with reason `cross_component` (directives with `templates: 0`; a non-literal metadata array marks every member of the class), and `ast_rename_symbol` refuses them with `INCOMPLETE_EVIDENCE` (#410).
+- Upgrading the `structural-code-editing` skill over an unmodified install from npm `0.11.0`–`0.15.1` failed with a conflict: `0.13.0`–`0.15.1` had no recorded predecessor, and the `0.11.0`–`0.12.0` predecessors did not list `references/operations.md`. Every published byte set is now recorded, and the skill version is `4.7.0` (#425).
+
+## [0.15.1] — published to `next`, verification failed, not promoted (2026-11-05)
+
+### Changed
+
+- `@angular/compiler` 18 and 19 are now supported (`>=18.0.0 <23.0.0`); an Angular 18 project previously reported `compiler_unsupported` and missed every template usage (#399).
+
+### Fixed
+
+- `publish-next` waits up to five minutes (was two) for the registry to expose an accepted publish before giving up, and when that bound is exhausted after a publish that did not throw, it now points the maintainer at `verify-next` instead of asking for a new dispatch that would try to republish immutable bytes. `0.15.0` was reported as failed 46 seconds before the registry served it (#395).
+
+### Release status
+
+- npm published these immutable bytes under `next` with provenance and the expected Git commit (`20548017b7c9266160963a0272ce8757b8f42a77`, integrity `sha512-+DkpmFAHMnvfKmZhEN8Rrk1baryumHcAkXgcw5YABhC6vzaAmD1WiPLP25YzoFNzSPFgz+L11yW/Nd4Ukq2Ixw==`, publish run `41970126401`, the first `publish-next` to confirm the registry readback under the widened bound). Public-registry verification (run `41970518670`) then failed for the same reason as `0.14.3` and `0.15.0`: the consumer install resolves `minimatch@10.2.6` through `ts-morph@28.0.0`, flagged by `npm audit` for GHSA-g3hv-75wg-m249 (#361). `0.15.1` supersedes `0.15.0` on `next` and was never promoted to `latest`, tagged in Git, or released on GitHub.
+
+## [0.15.0] — published to `next`, verification failed, not promoted (2026-11-04)
 
 ### Added
 
@@ -29,6 +63,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 - `ast_find_references` and `ast_rename_symbol` no longer count the declaration identifier as a reference. When a member was used before its declaration in source order, ts-morph returned the declaration identifier among the references, so the declaration appeared twice and `reference_count` was inflated by one. The declaration is now reported once and `reference_count` counts only real references (#390).
 - The dsh-adapter smoke no longer reports a surviving Harness process tree when descendants are still exiting after a clean shutdown on a loaded runner. The lifecycle assertion now polls the owned process tree with a bounded ten-second deadline, and when survivors remain it keeps failing but lists each PID with its command line and parent chain (#363).
 
+### Release status
+
+- npm published these immutable bytes under `next` with provenance and the expected Git commit (`5b2d483001d21ef29a760a9c0ae538dc719f11ea`, integrity `sha512-4dUo7lyTyIGMPhWfVHHZ0BnUMXNAiSIapItorm3VTGiJXm8JyL6jW5lrNlj1LGyONAGtA6S6cHoFtiZxakGy1A==`, publish run `41905976154`). Public-registry verification (run `41906680048`) then failed for the same reason as `0.14.3`: the consumer install resolves `minimatch@10.2.6` through `ts-morph@28.0.0`, flagged by `npm audit` for GHSA-g3hv-75wg-m249 (#361). `0.15.0` was never promoted to `latest`, tagged in Git, or released on GitHub; the version that ships the ts-morph fix will supersede it.
+
 ## [0.14.3] — published to `next`, verification failed, not promoted (2026-11-01)
 
 ### Security

package/README.md

@@ -81,7 +81,7 @@ These fields are additive: existing edge shapes, kind strings, defaults, and pub
 
 ### Angular templates
 
-In an Angular project, `ast_find_references` also reports usages of a component member in its template, and `ast_rename_symbol` rewrites external templates as part of the same reviewed plan. This needs the project's own `@angular/compiler`. The server does not bundle it: it is an optional peer dependency (`>=20.0.0 <23.0.0`, majors 20 to 22) that Angular projects already install next to `@angular/core`. Nothing changes for projects without `@angular/core`.
+In an Angular project, `ast_find_references` also reports usages of a component member in its own and consumer templates, and `ast_rename_symbol` rewrites external templates as part of the same reviewed plan. This needs the project's own `@angular/compiler`. The server does not bundle it: it is an optional peer dependency (`>=18.0.0 <23.0.0`, majors 18 to 22) that Angular projects already install next to `@angular/core`. Nothing changes for projects without `@angular/core`.
 
 Install or align it in the target project when the response reports `compiler_missing` or `compiler_unsupported`:
 
@@ -92,9 +92,12 @@ yarn add --dev @angular/compiler@^21   # or npm install --save-dev @angular/comp
 Template evidence is explicit about what it proves:
 
 - Each item carries `origin` (`compiler`, `template_external`, `template_inline`); the response adds `template_coverage` and `template_reference_count`. Only `template_coverage.status: "completed"` supports a claim that no template usage exists.
-- Rename returns `INCOMPLETE_EVIDENCE` when coverage is `unfinished` or `unsupported`, and `MUTATION_BLOCKED` for inline templates, a new name that collides with a template local, or `$any`. Inline templates are never rewritten.
+- Members bound through the selector (`@Input`, `@Output`, `input()`, `output()`, `model()`, literal aliases, or literal entries of the `inputs` / `outputs` metadata) also list their bindings (kinds `TemplateInputBinding` for `[x]`, `TemplateAttribute` for `x="lit"`, `TemplateTwoWayBinding` for `[(x)]` and `TemplateOutputBinding` for `(y)` and `(xChange)`) in consumer templates of components whose literal standalone `imports` or NgModule scope contains the declaring component. A `@Pipe` class with a literal `name` and its `transform` list `| name` usages (kind `TemplatePipeName`) in the same way. A same selector or pipe name outside that scope is ignored.
+- For these members, `completed` means every component template inside the Project was read and every match resolved. `hostDirectives`, `@Directive` inputs and outputs, and non-literal scopes, aliases, metadata or pipe names stay `unfinished` with reason `cross_component`. Runtime bindings (`setInput`, router input binding, `createComponent`) and consumers outside the Project are never examined.
+- Rename rewrites consumer bindings of a selector-bound member when coverage is `completed`, keeping the binding syntax, values and alias-keyed bindings. It returns `INCOMPLETE_EVIDENCE` when coverage is `unfinished` or `unsupported` (including `hostDirectives`, `@Directive` members and metadata-listed members), and `MUTATION_BLOCKED` for inline templates, a name collision with a template local or another binding of the element, `[(x)]` on a non-`model()` pair, `$any`, or a name in the selector. Inline templates are never rewritten.
+- Renaming a `@Pipe` class applies TypeScript edits only and keeps the `name` literal and every `| name` usage; renaming `transform` returns `INCOMPLETE_EVIDENCE`.
 - `ast_explore` stays TypeScript-only for references; template evidence there is tracked in #380. Use `ast_find_references` for template usages.
-- Diagnostics stay TypeScript-only: template errors are not detected, so run the project's Angular build or tests after a rename.
+- Diagnostics stay TypeScript-only: template errors are not detected, so run the project's Angular build or tests after a rename. Template type checking of rename plans is tracked in #421.
 - Yarn PnP projects without a `node_modules` directory cannot resolve the compiler and report `unfinished`; use `nodeLinker: node-modules` for template coverage.
 
 ## Why this helps
@@ -371,7 +374,7 @@ For a local candidate, pack and install its tarball instead:
 
 ```bash
 yarn pack --out ast-mcp-server-%v.tgz
-dsh plugin --profile web add ./ast-mcp-server-0.15.0.tgz
+dsh plugin --profile web add ./ast-mcp-server-0.16.0.tgz
 ```
 
 The first supported surface is **reads + prepare + preview**. Every apply path is

package/cordis.patch.yml

@@ -3,7 +3,7 @@
 # Mounts the packaged `ast-mcp-server` stdio command through the official
 # `@deepseek-ai/dsh-mcp-client` bridge. Harness does not resolve MCP binaries
 # from PATH, so the entrypoint is resolved relative to the profile directory
-# (`baseUrl`), where `dsh plugin --profile <name> add ./ast-mcp-server-0.15.0.tgz`
+# (`baseUrl`), where `dsh plugin --profile <name> add ./ast-mcp-server-0.16.0.tgz`
 # installs a locally packed package as a dependency.
 #
 # First-slice surface: reads + prepare + preview. Every apply path is denied

package/dist/services/angular-decorators.js

@@ -0,0 +1,218 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { Node, } from "ts-morph";
+/** The text of a plain string literal, or undefined for anything computed. */
+export function literalString(node) {
+    return Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)
+        ? node.getLiteralText()
+        : undefined;
+}
+/** Major version of the project's resolvable `@angular/core`, or undefined when unknown. */
+export function angularCoreMajor(context) {
+    try {
+        const manifest = createRequire(context.tsConfigFilePath).resolve("@angular/core/package.json");
+        const major = /^(\d+)\./u.exec(String(JSON.parse(readFileSync(manifest, "utf8")).version));
+        return major ? Number(major[1]) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** True when `callee` names `exportName` imported from `@angular/core` (named, aliased, or namespace). */
+export function isAngularCoreExport(callee, exportName) {
+    return callee
+        .getSourceFile()
+        .getImportDeclarations()
+        .filter((declaration) => declaration.getModuleSpecifierValue() === "@angular/core")
+        .some((declaration) => {
+        const namespace = declaration.getNamespaceImport();
+        if (Node.isPropertyAccessExpression(callee)) {
+            return (callee.getName() === exportName &&
+                callee.getExpression().getText() === namespace?.getText());
+        }
+        return declaration
+            .getNamedImports()
+            .some((specifier) => specifier.getName() === exportName &&
+            (specifier.getAliasNode()?.getText() ?? exportName) === callee.getText());
+    });
+}
+export function isCoreDecorator(decorator, name) {
+    const callee = decorator.getCallExpression()?.getExpression();
+    return callee !== undefined && isAngularCoreExport(callee, name);
+}
+function isComponentDecorator(decorator) {
+    return isCoreDecorator(decorator, "Component");
+}
+export function componentDecorator(cls) {
+    return cls.getDecorators().find(isComponentDecorator);
+}
+/** Pipe usages live in other components' templates, which are never read. */
+export function isPipeClass(cls) {
+    return cls.getDecorators().some((decorator) => isCoreDecorator(decorator, "Pipe"));
+}
+/** Directives have no template; their selector-public members are bound only in consuming templates. */
+export function isDirectiveClass(cls) {
+    return cls.getDecorators().some((decorator) => isCoreDecorator(decorator, "Directive"));
+}
+/**
+ * Members listed in the `inputs` / `outputs` metadata arrays of `@Component` / `@Directive`.
+ * Fails closed: a non-literal array or element makes every member of the class public.
+ */
+export function isMetadataPublic(cls, memberName) {
+    const literalName = literalString;
+    const listsMember = (element) => {
+        const text = literalName(element);
+        if (text !== undefined)
+            return text.split(":")[0].trim() === memberName;
+        if (!Node.isObjectLiteralExpression(element))
+            return true;
+        const name = element.getProperty("name");
+        const value = Node.isPropertyAssignment(name) ? literalName(name.getInitializer()) : undefined;
+        return value === undefined || value === memberName;
+    };
+    return cls
+        .getDecorators()
+        .filter((decorator) => ["Component", "Directive"].some((name) => isCoreDecorator(decorator, name)))
+        .some((decorator) => {
+        const metadata = decorator.getArguments()[0];
+        if (!Node.isObjectLiteralExpression(metadata))
+            return false;
+        return ["inputs", "outputs"].some((key) => {
+            const property = metadata.getProperty(key);
+            if (!property)
+                return false;
+            const list = Node.isPropertyAssignment(property) ? property.getInitializer() : undefined;
+            return !Node.isArrayLiteralExpression(list) || list.getElements().some(listsMember);
+        });
+    });
+}
+/** Members bound through the selector (`@Input`, `@Output`, `input()`, `output()`, `model()`). */
+export function isSelectorPublic(node) {
+    const decorated = Node.isDecoratable(node) &&
+        node
+            .getDecorators()
+            .some((decorator) => ["Input", "Output"].some((name) => isCoreDecorator(decorator, name)));
+    if (decorated || !Node.isPropertyDeclaration(node))
+        return decorated;
+    const initializer = node.getInitializer();
+    if (!Node.isCallExpression(initializer))
+        return false;
+    let callee = initializer.getExpression();
+    if (Node.isPropertyAccessExpression(callee) && callee.getName() === "required") {
+        callee = callee.getExpression(); // input.required(...) / model.required(...)
+    }
+    return ["input", "output", "model"].some((name) => isAngularCoreExport(callee, name));
+}
+/** The alias in a literal options object (or a literal string), the fallback when absent, else undefined. */
+function aliasOf(options, fallback) {
+    if (options === undefined)
+        return fallback;
+    const text = literalString(options);
+    if (text !== undefined)
+        return text;
+    if (!Node.isObjectLiteralExpression(options))
+        return undefined;
+    const properties = options.getProperties();
+    const computed = (property) => Node.isPropertyAssignment(property) && Node.isComputedPropertyName(property.getNameNode());
+    if (properties.some((property) => Node.isSpreadAssignment(property) || computed(property))) {
+        return undefined;
+    }
+    const alias = options.getProperty("alias");
+    if (alias === undefined)
+        return fallback;
+    return Node.isPropertyAssignment(alias) ? literalString(alias.getInitializer()) : undefined;
+}
+/**
+ * Public binding names of an `@Input` / `@Output` / `input()` / `output()` / `model()` member,
+ * following literal aliases. A `model()` binds `x` and `xChange`. Undefined when an alias or the
+ * options are not literal, because the binding name then cannot be known.
+ */
+export function bindingNames(node, name) {
+    if (Node.isDecoratable(node)) {
+        for (const decorator of node.getDecorators()) {
+            const kind = ["Input", "Output"].find((id) => isCoreDecorator(decorator, id));
+            if (!kind)
+                continue;
+            const args = decorator.getArguments();
+            const alias = args.length <= 1 ? aliasOf(args[0], name) : undefined;
+            if (alias === undefined || (kind === "Output" && args[0] && !literalString(args[0]))) {
+                return undefined;
+            }
+            return kind === "Input" ? { inputs: [alias], outputs: [] } : { inputs: [], outputs: [alias] };
+        }
+    }
+    const initializer = Node.isPropertyDeclaration(node) ? node.getInitializer() : undefined;
+    if (!Node.isCallExpression(initializer))
+        return undefined;
+    let callee = initializer.getExpression();
+    const required = Node.isPropertyAccessExpression(callee) && callee.getName() === "required";
+    if (required)
+        callee = callee.getExpression();
+    const kind = ["input", "model", "output"].find((id) => isAngularCoreExport(callee, id));
+    if (!kind)
+        return undefined;
+    // The initial value comes first for input() and model(); required() and output() take options only.
+    const optionsAt = kind !== "output" && !required ? 1 : 0;
+    const args = initializer.getArguments();
+    if (args.length > optionsAt + 1)
+        return undefined;
+    const alias = aliasOf(args[optionsAt], name);
+    if (alias === undefined)
+        return undefined;
+    if (kind === "input")
+        return { inputs: [alias], outputs: [] };
+    if (kind === "output")
+        return { inputs: [], outputs: [alias] };
+    return { inputs: [alias], outputs: [`${alias}Change`] };
+}
+/**
+ * Public names of a member listed in the `inputs` / `outputs` metadata (`'x'`, `'x: alias'`,
+ * `{ name, alias }`). Undefined when any array or element is not literal, matching #410's fail-closed rule.
+ */
+export function metadataBindingNames(cls, name) {
+    const found = { inputs: [], outputs: [] };
+    for (const decorator of cls.getDecorators()) {
+        if (!["Component", "Directive"].some((id) => isCoreDecorator(decorator, id)))
+            continue;
+        const metadata = decorator.getArguments()[0];
+        if (!Node.isObjectLiteralExpression(metadata))
+            continue;
+        for (const key of ["inputs", "outputs"]) {
+            const property = metadata.getProperty(key);
+            if (!property)
+                continue;
+            const list = Node.isPropertyAssignment(property) ? property.getInitializer() : undefined;
+            if (!Node.isArrayLiteralExpression(list))
+                return undefined;
+            for (const element of list.getElements()) {
+                let listed;
+                let alias;
+                const text = literalString(element);
+                if (text !== undefined) {
+                    const [member = "", rest] = text.split(":");
+                    listed = member.trim();
+                    alias = rest === undefined ? listed : rest.trim();
+                }
+                else if (Node.isObjectLiteralExpression(element)) {
+                    const nameProperty = element.getProperty("name");
+                    const value = Node.isPropertyAssignment(nameProperty)
+                        ? literalString(nameProperty.getInitializer())
+                        : undefined;
+                    if (value === undefined)
+                        return undefined;
+                    listed = value;
+                    alias = aliasOf(element, listed);
+                }
+                else {
+                    return undefined;
+                }
+                if (listed !== name)
+                    continue;
+                if (alias === undefined)
+                    return undefined;
+                found[key].push(alias);
+            }
+        }
+    }
+    return found;
+}

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

@@ -0,0 +1,111 @@
+// BindingType.Property / TwoWay and ParsedEventType.Regular / TwoWay are stable across v18-v22.
+// Animation members were renumbered in v20 and are deliberately never matched.
+const PROPERTY = 0;
+const TWO_WAY = 5;
+const REGULAR_EVENT = 0;
+const TWO_WAY_EVENT = 2;
+const KINDS = {
+    input: "TemplateInputBinding",
+    static_input: "TemplateAttribute",
+    two_way: "TemplateTwoWayBinding",
+    output: "TemplateOutputBinding",
+};
+/**
+ * Cheap necessary condition: an alternative can match only if its element (or first attribute)
+ * name occurs in the text. Alternatives with neither (such as `.card`) always require a parse.
+ */
+export function mayMatch(compiler, selector, text) {
+    const lower = text.toLowerCase();
+    return compiler.CssSelector.parse(selector).some((alternative) => {
+        const required = alternative.element ?? alternative.attrs[0];
+        return !required || required === "*" || lower.includes(required.toLowerCase());
+    });
+}
+function pairedTwoWayInput(target, event) {
+    return (target.outputs.includes(event) &&
+        event.endsWith("Change") &&
+        target.inputs.includes(event.slice(0, -"Change".length)));
+}
+/** Pure: finds the bindings of `target` in a parsed consumer template, matching by selector. */
+export function extractConsumerUsages(compiler, nodes, text, target, tick = () => { }) {
+    const matcher = new compiler.SelectorMatcher();
+    matcher.addSelectables(compiler.CssSelector.parse(target.selector));
+    const scan = { matched: false, opaque: false, usages: [] };
+    const consider = (element) => {
+        const nodeSelector = compiler.createCssSelectorFromNode(element);
+        let hit = false;
+        matcher.match(nodeSelector, () => (hit = true));
+        if (!hit)
+            return;
+        scan.matched = true;
+        const elementMatches = (selector) => {
+            try {
+                const other = new compiler.SelectorMatcher();
+                other.addSelectables(compiler.CssSelector.parse(selector));
+                let found = false;
+                other.match(nodeSelector, () => (found = true));
+                return found;
+            }
+            catch {
+                return false; // a selector the compiler cannot parse cannot match either
+            }
+        };
+        const add = (binding, name, keySpan) => {
+            const start = keySpan?.start.offset;
+            const end = keySpan?.end.offset;
+            // Runtime check, not a typing: the key span must slice to exactly the binding name.
+            if (start === undefined || text.slice(start, end) !== name)
+                scan.opaque = true;
+            else {
+                scan.usages.push({
+                    start,
+                    end,
+                    kind: KINDS[binding],
+                    binding,
+                    bindingName: name,
+                    elementMatches,
+                });
+            }
+        };
+        for (const input of element.inputs) {
+            const twoWay = input.type === TWO_WAY;
+            if ((input.type === PROPERTY || twoWay) && target.inputs.includes(input.name)) {
+                add(twoWay ? "two_way" : "input", input.name, input.keySpan);
+            }
+        }
+        for (const attribute of element.attributes) {
+            if (target.inputs.includes(attribute.name))
+                add("static_input", attribute.name, attribute.keySpan);
+        }
+        for (const output of element.outputs) {
+            // The event half of `[(x)]` on a model pair is already reported through the input half.
+            if (output.type === TWO_WAY_EVENT && pairedTwoWayInput(target, output.name))
+                continue;
+            const regular = output.type === REGULAR_EVENT || output.type === TWO_WAY_EVENT;
+            if (regular && target.outputs.includes(output.name))
+                add("output", output.name, output.keySpan);
+        }
+    };
+    class Visitor extends compiler.TmplAstRecursiveVisitor {
+        visitElement(element) {
+            tick();
+            consider(element);
+            if (!element.attributes.some((attribute) => attribute.name === "ngNonBindable")) {
+                super.visitElement(element);
+            }
+        }
+        visitTemplate(template) {
+            tick();
+            super.visitTemplate(template);
+        }
+        // Selectorless nodes reference classes by name, which selector matching cannot see.
+        visitComponent() {
+            scan.opaque = true;
+        }
+        visitDirective() {
+            scan.opaque = true;
+        }
+    }
+    compiler.tmplAstVisitAll(new Visitor(), nodes);
+    return scan;
+}

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

@@ -0,0 +1,119 @@
+import { Node, SyntaxKind } from "ts-morph";
+import { bindingNames, componentDecorator, isCoreDecorator, isMetadataPublic, isSelectorPublic, literalString, metadataBindingNames, } from "./angular-decorators.js";
+import { memberOwner } from "./angular-templates.js";
+import { PublicOperationalError } from "./public-errors.js";
+const blocked = (reason) => new PublicOperationalError("MUTATION_BLOCKED", reason);
+const CHANGE = "Change";
+function selectorOf(cls) {
+    const decorator = componentDecorator(cls) ??
+        cls.getDecorators().find((candidate) => isCoreDecorator(candidate, "Directive"));
+    const metadata = decorator?.getArguments()[0];
+    if (!Node.isObjectLiteralExpression(metadata))
+        return undefined;
+    const property = metadata.getProperty("selector");
+    return literalString(Node.isPropertyAssignment(property) ? property.getInitializer() : undefined);
+}
+/** Public names of every selector-bound member of `cls` except `skip`; undefined when any is unknowable. */
+function publicNames(cls, skip) {
+    const names = new Set();
+    for (const member of cls.getMembers()) {
+        if (member === skip)
+            continue;
+        const name = member.getName?.();
+        if (name === undefined)
+            continue;
+        const listed = isMetadataPublic(cls, name);
+        if (!listed && !isSelectorPublic(member))
+            continue;
+        // A member both decorated and listed in metadata has ambiguous binding names.
+        const found = listed && isSelectorPublic(member)
+            ? undefined
+            : listed
+                ? metadataBindingNames(cls, name)
+                : bindingNames(member, name);
+        if (!found)
+            return undefined;
+        [...found.inputs, ...found.outputs].forEach((entry) => names.add(entry));
+    }
+    return names;
+}
+/** Directives other than `target` whose selector matches the element of a consumer binding. */
+function siblingDirectives(context, target) {
+    return context.project
+        .getSourceFiles()
+        .filter((file) => !file.isDeclarationFile() && !file.isFromExternalLibrary())
+        .flatMap((file) => file.getDescendantsOfKind(SyntaxKind.ClassDeclaration))
+        .filter((cls) => cls !== target &&
+        cls
+            .getDecorators()
+            .some((decorator) => ["Component", "Directive"].some((name) => isCoreDecorator(decorator, name))));
+}
+function hasHostDirectives(cls) {
+    return cls.getDecorators().some((decorator) => {
+        const metadata = decorator.getArguments()[0];
+        return Node.isObjectLiteralExpression(metadata) && !!metadata.getProperty("hostDirectives");
+    });
+}
+/**
+ * Plans the template edit of every usage with its own `newText`, or throws `MUTATION_BLOCKED` when
+ * the rewrite cannot be proven safe. Must run before the TypeScript rename mutates the program.
+ * Own-template usages are the member name itself. Consumer bindings use the public binding name:
+ * an alias-keyed binding is left alone, and a `model()` event key becomes `<newName>Change`.
+ */
+export function planTemplateEdits(node, usages, newName, context) {
+    const owner = memberOwner(node);
+    const consumers = usages.filter((usage) => usage.role === "consumer");
+    if (!owner || !isSelectorPublic(node)) {
+        return usages.map((usage) => ({ usage, newText: newName }));
+    }
+    const names = bindingNames(node, owner.name);
+    if (!names)
+        throw blocked("The public binding names of the member cannot be determined.");
+    const isModel = names.inputs.length === 1 && names.outputs.length === 1;
+    const published = [...names.inputs, ...names.outputs];
+    const renamed = new Map([
+        [owner.name, newName],
+        ...(isModel ? [[`${owner.name}${CHANGE}`, `${newName}${CHANGE}`]] : []),
+    ].filter(([from]) => published.includes(from)));
+    if (renamed.size > 0)
+        assertNewNamesFree(owner.cls, node, renamed, consumers, context);
+    const edits = [];
+    for (const usage of usages) {
+        const newText = usage.role === "own" ? newName : renamed.get(usage.bindingName ?? "");
+        if (newText === undefined)
+            continue; // an alias-keyed binding still names the alias
+        if (usage.binding === "two_way" && !isModel) {
+            throw blocked("A two-way binding needs a model() member: its paired event cannot be renamed.");
+        }
+        edits.push({ usage, newText });
+    }
+    return edits;
+}
+function assertNewNamesFree(cls, node, renamed, consumers, context) {
+    const incoming = [...renamed.values()];
+    const others = publicNames(cls, node);
+    if (!others)
+        throw blocked("Another member's public binding names cannot be determined.");
+    if (incoming.some((name) => others.has(name))) {
+        throw blocked("The new name duplicates another input, output or alias of the same directive.");
+    }
+    const tokens = new Set((selectorOf(cls) ?? "")
+        .toLowerCase()
+        .split(/[^\w$-]+/u)
+        .filter(Boolean));
+    if ([...renamed.keys(), ...incoming].some((name) => tokens.has(name.toLowerCase()))) {
+        throw blocked("The binding name appears in the directive's own selector.");
+    }
+    const siblings = siblingDirectives(context, cls);
+    for (const usage of consumers) {
+        for (const sibling of siblings) {
+            const selector = selectorOf(sibling);
+            if (selector === undefined || !usage.elementMatches?.(selector))
+                continue;
+            const theirs = hasHostDirectives(sibling) ? undefined : publicNames(sibling);
+            if (!theirs || incoming.some((name) => theirs.has(name))) {
+                throw blocked("Another directive on the same element binds the new name or cannot be listed.");
+            }
+        }
+    }
+}