@taiga-ui/eslint-plugin-experience-next 0.466.0 → 0.467.0

package/index.esm.js

@@ -905,10 +905,16 @@ var recommended = defineConfig([
                 },
             ],
             '@taiga-ui/experience-next/no-deep-imports-to-indexed-packages': 'error',
+            '@taiga-ui/experience-next/no-fully-untracked-effect': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
             '@taiga-ui/experience-next/no-redundant-type-annotation': 'error',
+            '@taiga-ui/experience-next/no-signal-reads-after-await-in-reactive-context': 'error',
+            '@taiga-ui/experience-next/no-untracked-outside-reactive-context': 'error',
+            '@taiga-ui/experience-next/no-useless-untracked': 'error',
             '@taiga-ui/experience-next/object-single-line': ['error', { printWidth: 90 }],
             '@taiga-ui/experience-next/prefer-multi-arg-push': 'error',
+            '@taiga-ui/experience-next/prefer-untracked-incidental-signal-reads': 'error',
+            '@taiga-ui/experience-next/prefer-untracked-signal-getter': 'error',
             '@taiga-ui/experience-next/short-tui-imports': 'error',
             '@taiga-ui/experience-next/standalone-imports-sort': [
                 'error',
@@ -1706,7 +1712,7 @@ const config$2 = {
 const MESSAGE_ID$5 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
 const createRule$d = ESLintUtils.RuleCreator((name) => name);
-const rule$a = createRule$d({
+const rule$g = createRule$d({
     create(context) {
         return {
             'NewExpression[callee.name="InjectionToken"]'(node) {
@@ -1774,7 +1780,7 @@ const DEFAULT_OPTIONS = {
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
 const createRule$c = ESLintUtils.RuleCreator((name) => name);
-const rule$9 = createRule$c({
+const rule$f = createRule$c({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -2062,6 +2068,534 @@ function stripKnownExtensions(filePathOrSpecifier) {
     return filePathOrSpecifier.replace(/\.(?:d\.ts|ts|tsx|js|jsx|mjs|cjs)$/, '');
 }
 
+const ANGULAR_CORE$1 = '@angular/core';
+/**
+ * Returns the local name bound to a named import from a given source.
+ * Handles aliased imports: `import { untracked as ngUntracked } from '@angular/core'`
+ * returns `'ngUntracked'` for `exportedName = 'untracked'`.
+ */
+function getLocalNameForImport(program, source, exportedName) {
+    for (const node of program.body) {
+        if (node.type !== AST_NODE_TYPES.ImportDeclaration ||
+            node.source.value !== source) {
+            continue;
+        }
+        for (const spec of node.specifiers) {
+            if (spec.type !== AST_NODE_TYPES.ImportSpecifier) {
+                continue;
+            }
+            const imported = spec.imported.type === AST_NODE_TYPES.Identifier
+                ? spec.imported.name
+                : spec.imported.value;
+            if (imported === exportedName) {
+                return spec.local.name;
+            }
+        }
+    }
+    return null;
+}
+function findAngularCoreImports(program) {
+    return program.body.filter((node) => node.type === AST_NODE_TYPES.ImportDeclaration &&
+        node.source.value === ANGULAR_CORE$1);
+}
+function findRuntimeAngularCoreImport(program) {
+    return (findAngularCoreImports(program).find((node) => node.importKind !== 'type') ?? null);
+}
+function findAngularCoreImportSpecifier(program, exportedName) {
+    for (const importDecl of findAngularCoreImports(program)) {
+        for (const specifier of importDecl.specifiers) {
+            if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) {
+                continue;
+            }
+            const imported = specifier.imported.type === AST_NODE_TYPES.Identifier
+                ? specifier.imported.name
+                : specifier.imported.value;
+            if (imported === exportedName) {
+                return { importDecl, specifier };
+            }
+        }
+    }
+    return null;
+}
+
+function isFunctionLike$1(node) {
+    return (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === AST_NODE_TYPES.FunctionExpression);
+}
+function getOrderedChildren(node) {
+    if (isFunctionLike$1(node)) {
+        const children = [
+            ...node.params,
+            node.body,
+        ];
+        return children.filter((child) => child !== undefined && child !== null);
+    }
+    if (node.type === AST_NODE_TYPES.BlockStatement) {
+        return node.body;
+    }
+    if (node.type === AST_NODE_TYPES.Program) {
+        return node.body;
+    }
+    if (node.type === AST_NODE_TYPES.IfStatement) {
+        return node.alternate
+            ? [node.test, node.consequent, node.alternate]
+            : [node.test, node.consequent];
+    }
+    if (node.type === AST_NODE_TYPES.ConditionalExpression) {
+        return [node.test, node.consequent, node.alternate];
+    }
+    if (node.type === AST_NODE_TYPES.WhileStatement) {
+        return [node.test, node.body];
+    }
+    if (node.type === AST_NODE_TYPES.DoWhileStatement) {
+        return [node.body, node.test];
+    }
+    if (node.type === AST_NODE_TYPES.ForStatement) {
+        const children = [
+            node.init && 'type' in node.init ? node.init : null,
+            node.test,
+            node.update,
+            node.body,
+        ];
+        return children.filter((child) => child !== null);
+    }
+    if (node.type === AST_NODE_TYPES.ForInStatement ||
+        node.type === AST_NODE_TYPES.ForOfStatement) {
+        return [node.left, node.right, node.body];
+    }
+    const children = [];
+    for (const key of Object.keys(node)) {
+        if (key === 'parent') {
+            continue;
+        }
+        const child = node[key];
+        if (Array.isArray(child)) {
+            for (const item of child) {
+                if (item && typeof item === 'object' && 'type' in item) {
+                    children.push(item);
+                }
+            }
+        }
+        else if (child && typeof child === 'object' && 'type' in child) {
+            children.push(child);
+        }
+    }
+    return children;
+}
+/**
+ * Walks the synchronous portion of a reactive scope.
+ *
+ * - Stops descending into nested function boundaries, since they run in their
+ *   own call context and should not be treated as reads/writes of the current
+ *   reactive scope.
+ * - Traverses the argument of `await`, because it is evaluated synchronously,
+ *   then stops visiting subsequent sibling nodes in the current execution path.
+ */
+function walkSynchronousAst(root, visitor) {
+    traverse(root, true);
+    function traverse(node, isRoot = false) {
+        if (visitor(node) === false) {
+            return false;
+        }
+        if (!isRoot && isFunctionLike$1(node)) {
+            return false;
+        }
+        if (node.type === AST_NODE_TYPES.AwaitExpression) {
+            return traverse(node.argument, false) || true;
+        }
+        for (const child of getOrderedChildren(node)) {
+            if (traverse(child, false)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+/**
+ * Walks nodes that run after an async boundary inside a reactive callback.
+ *
+ * The traversal is intentionally conservative:
+ * - it never descends into nested function boundaries
+ * - it propagates async state through straight-line code
+ * - it does not propagate branch-local `await` from optional control-flow
+ *   bodies into later siblings, which avoids noisy false positives
+ */
+function walkAfterAsyncBoundaryAst(root, visitor) {
+    traverse(root, true, false);
+    function traverse(node, isRoot = false, afterBoundary = false) {
+        if (afterBoundary) {
+            visitor(node);
+        }
+        if (!isRoot && isFunctionLike$1(node)) {
+            return false;
+        }
+        if (node.type === AST_NODE_TYPES.AwaitExpression) {
+            traverse(node.argument, false, afterBoundary);
+            return true;
+        }
+        if (node.type === AST_NODE_TYPES.BlockStatement ||
+            node.type === AST_NODE_TYPES.Program) {
+            let crossed = afterBoundary;
+            for (const child of node.body) {
+                const childCrossed = traverse(child, false, crossed);
+                crossed = crossed || childCrossed;
+            }
+            return crossed && !afterBoundary;
+        }
+        if (node.type === AST_NODE_TYPES.IfStatement) {
+            const crossedInTest = traverse(node.test, false, afterBoundary);
+            const branchAfterBoundary = afterBoundary || crossedInTest;
+            traverse(node.consequent, false, branchAfterBoundary);
+            if (node.alternate) {
+                traverse(node.alternate, false, branchAfterBoundary);
+            }
+            return crossedInTest && !afterBoundary;
+        }
+        let crossed = afterBoundary;
+        for (const child of getOrderedChildren(node)) {
+            const childCrossed = traverse(child, false, crossed);
+            crossed = crossed || childCrossed;
+        }
+        return crossed && !afterBoundary;
+    }
+}
+/**
+ * Shallow AST walker. Visits `root` and every descendant, skipping the
+ * synthetic `parent` back-pointer to avoid cycles.
+ *
+ * If the visitor returns `false` for a node, that node's children are NOT
+ * visited (prune / stop-descend). Any other return value (including `void`)
+ * continues the walk.
+ */
+function walkAst(root, visitor) {
+    if (visitor(root) === false) {
+        return;
+    }
+    for (const key of Object.keys(root)) {
+        if (key === 'parent') {
+            continue;
+        }
+        const child = root[key];
+        if (Array.isArray(child)) {
+            for (const item of child) {
+                if (item && typeof item === 'object' && 'type' in item) {
+                    walkAst(item, visitor);
+                }
+            }
+        }
+        else if (child && typeof child === 'object' && 'type' in child) {
+            walkAst(child, visitor);
+        }
+    }
+}
+
+const ANGULAR_CORE = '@angular/core';
+const SIGNAL_WRITE_METHODS = new Set(['mutate', 'set', 'update']);
+const AFTER_RENDER_EFFECT_PHASES = new Map([
+    ['earlyRead', 'afterRenderEffect().earlyRead'],
+    ['mixedReadWrite', 'afterRenderEffect().mixedReadWrite'],
+    ['read', 'afterRenderEffect().read'],
+    ['write', 'afterRenderEffect().write'],
+]);
+function isReactiveCallback(node) {
+    return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        node?.type === AST_NODE_TYPES.FunctionExpression);
+}
+function getPropertyName(property) {
+    if (property.computed) {
+        return null;
+    }
+    if (property.key.type === AST_NODE_TYPES.Identifier) {
+        return property.key.name;
+    }
+    return typeof property.key.value === 'string' ? property.key.value : null;
+}
+function isAngularCoreCall(node, program, exportedName) {
+    const localName = getLocalNameForImport(program, ANGULAR_CORE, exportedName);
+    if (!localName) {
+        return false;
+    }
+    return (node.callee.type === AST_NODE_TYPES.Identifier &&
+        node.callee.name === localName &&
+        node.arguments.length >= 1);
+}
+function appendFirstArgReactiveScope(scopes, call, kind) {
+    const [arg] = call.arguments;
+    if (!isReactiveCallback(arg)) {
+        return;
+    }
+    scopes.push({ callback: arg, kind, owner: call, reportNode: call });
+}
+function appendObjectPropertyReactiveScopes(scopes, call, object, labels) {
+    for (const property of object.properties) {
+        if (property.type !== AST_NODE_TYPES.Property) {
+            continue;
+        }
+        const name = getPropertyName(property);
+        const label = name ? labels.get(name) : null;
+        if (!label || !isReactiveCallback(property.value)) {
+            continue;
+        }
+        scopes.push({
+            callback: property.value,
+            kind: label,
+            owner: call,
+            reportNode: property,
+        });
+    }
+}
+function isAngularEffectCall(node, program) {
+    return isAngularCoreCall(node, program, 'effect');
+}
+function isAngularUntrackedCall(node, program) {
+    return isAngularCoreCall(node, program, 'untracked');
+}
+function getReactiveScopes(node, program) {
+    const scopes = [];
+    const [arg] = node.arguments;
+    if (isAngularEffectCall(node, program)) {
+        appendFirstArgReactiveScope(scopes, node, 'effect()');
+    }
+    if (isAngularCoreCall(node, program, 'computed')) {
+        appendFirstArgReactiveScope(scopes, node, 'computed()');
+    }
+    if (isAngularCoreCall(node, program, 'linkedSignal')) {
+        appendFirstArgReactiveScope(scopes, node, 'linkedSignal()');
+        if (arg?.type === AST_NODE_TYPES.ObjectExpression) {
+            appendObjectPropertyReactiveScopes(scopes, node, arg, new Map([
+                ['computation', 'linkedSignal().computation'],
+                ['source', 'linkedSignal().source'],
+            ]));
+        }
+    }
+    if (isAngularCoreCall(node, program, 'resource')) {
+        if (arg?.type === AST_NODE_TYPES.ObjectExpression) {
+            appendObjectPropertyReactiveScopes(scopes, node, arg, new Map([
+                ['loader', 'resource().loader'],
+                ['params', 'resource().params'],
+            ]));
+        }
+    }
+    if (isAngularCoreCall(node, program, 'afterRenderEffect')) {
+        appendFirstArgReactiveScope(scopes, node, 'afterRenderEffect()');
+        if (arg?.type === AST_NODE_TYPES.ObjectExpression) {
+            appendObjectPropertyReactiveScopes(scopes, node, arg, AFTER_RENDER_EFFECT_PHASES);
+        }
+    }
+    return scopes;
+}
+function isNodeInsideSynchronousReactiveScope(node, callback) {
+    let found = false;
+    walkSynchronousAst(callback, (inner) => {
+        if (inner !== node) {
+            return;
+        }
+        found = true;
+        return false;
+    });
+    return found;
+}
+function findEnclosingReactiveScope(node, program) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type !== AST_NODE_TYPES.CallExpression) {
+            continue;
+        }
+        for (const scope of getReactiveScopes(current, program)) {
+            if (isNodeInsideSynchronousReactiveScope(node, scope.callback)) {
+                return scope;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Returns true when the TypeScript type at `node` is an Angular signal type.
+ * Uses duck-typing: callable type whose name contains "Signal", or whose
+ * string-keyed properties include the Angular `ɵ` brand.
+ *
+ * Falls back to `false` on any error.
+ */
+function isSignalType(node, checker, esTreeNodeToTSNodeMap) {
+    try {
+        const tsNode = esTreeNodeToTSNodeMap.get(node);
+        if (!tsNode) {
+            return false;
+        }
+        const type = checker.getTypeAtLocation(tsNode);
+        if (type.getCallSignatures().length === 0) {
+            return false;
+        }
+        if (checker.typeToString(type).includes('Signal')) {
+            return true;
+        }
+        const typeSymbol = type.getSymbol();
+        const aliasSymbol = type.aliasSymbol;
+        if (typeSymbol?.getName().includes('Signal') ||
+            aliasSymbol?.getName().includes('Signal')) {
+            return true;
+        }
+        return type
+            .getProperties()
+            .some((p) => p.name.startsWith('ɵ') || p.name === '__SIGNAL');
+    }
+    catch {
+        return false;
+    }
+}
+function isSignalReadCall(node, checker, esTreeNodeToTSNodeMap) {
+    const { callee } = node;
+    if (callee.type !== AST_NODE_TYPES.Identifier &&
+        callee.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    return isSignalType(callee, checker, esTreeNodeToTSNodeMap);
+}
+function isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap) {
+    if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const { object, property } = node.callee;
+    if (property.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    if (!SIGNAL_WRITE_METHODS.has(property.name)) {
+        return false;
+    }
+    return isSignalType(object, checker, esTreeNodeToTSNodeMap);
+}
+/**
+ * Returns true when `node` is a member expression `foo.bar` where `bar` is a
+ * TypeScript getter. Getter accesses are opaque — the getter body can read
+ * signals, so wrapping them in `untracked()` is justified.
+ */
+function isGetterMemberAccess(node, checker, esTreeNodeToTSNodeMap) {
+    try {
+        const tsNode = esTreeNodeToTSNodeMap.get(node);
+        if (!tsNode) {
+            return false;
+        }
+        const symbol = checker.getSymbolAtLocation(tsNode);
+        if (!symbol) {
+            return false;
+        }
+        return !!(symbol.flags & ts.SymbolFlags.GetAccessor);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Walks `scopeNode` and collects all signal reads and writes within it,
+ * NOT recursing into nested `untracked(...)` calls (their contents are
+ * already hidden from tracking).
+ */
+function collectSignalUsages(scopeNode, checker, esTreeNodeToTSNodeMap, program) {
+    const reads = [];
+    const writes = [];
+    walkSynchronousAst(scopeNode, (node) => {
+        if (node.type !== AST_NODE_TYPES.CallExpression) {
+            return;
+        }
+        // Skip contents of nested untracked — they are already isolated
+        if (isAngularUntrackedCall(node, program)) {
+            return false;
+        }
+        if (isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap)) {
+            writes.push(node);
+            for (const arg of node.arguments) {
+                walkSynchronousAst(arg, (inner) => {
+                    if (inner.type === AST_NODE_TYPES.CallExpression &&
+                        isSignalReadCall(inner, checker, esTreeNodeToTSNodeMap)) {
+                        reads.push(inner);
+                    }
+                });
+            }
+            return false;
+        }
+        if (isSignalReadCall(node, checker, esTreeNodeToTSNodeMap)) {
+            reads.push(node);
+        }
+        return;
+    });
+    return { reads, writes };
+}
+
+const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#reading-without-tracking-dependencies';
+const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
+const UNTRACKED_RULES_README_URL = 'https://github.com/taiga-family/taiga-ui/blob/main/projects/eslint-plugin-experience-next/README.md';
+const createUntrackedRule = ESLintUtils.RuleCreator((name) => `${UNTRACKED_RULES_README_URL}#${name}`);
+
+/**
+ * Collects signal reads that appear inside `untracked(...)` callbacks within
+ * `root`, without descending into nested `untracked(...)` scopes.
+ */
+function collectReadsInsideUntracked(root, checker, esTreeNodeToTSNodeMap, program) {
+    const reads = [];
+    walkSynchronousAst(root, (node) => {
+        if (node.type !== AST_NODE_TYPES.CallExpression) {
+            return;
+        }
+        if (!isAngularUntrackedCall(node, program)) {
+            return;
+        }
+        const [arg] = node.arguments;
+        if (!arg ||
+            (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+                arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+            return false;
+        }
+        walkSynchronousAst(arg, (inner) => {
+            if (inner.type === AST_NODE_TYPES.CallExpression &&
+                isSignalReadCall(inner, checker, esTreeNodeToTSNodeMap)) {
+                reads.push(inner);
+            }
+        });
+        return false; // Do not descend into nested untracked from the outer walk
+    });
+    return reads;
+}
+const rule$e = createUntrackedRule({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        return {
+            CallExpression(node) {
+                for (const scope of getReactiveScopes(node, program)) {
+                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    if (trackedReads.length > 0) {
+                        continue;
+                    }
+                    const untrackedReads = collectReadsInsideUntracked(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    if (untrackedReads.length === 0) {
+                        continue;
+                    }
+                    context.report({
+                        data: { kind: scope.kind },
+                        messageId: 'noTrackedReads',
+                        node: scope.reportNode,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow reactive callbacks where all signal reads are inside `untracked()`, leaving the callback without tracked dependencies',
+            url: ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL,
+        },
+        messages: {
+            noTrackedReads: 'This `{{ kind }}` callback has no tracked signal reads: every signal read is hidden inside `untracked()`, so changes will not re-run it. Move reads that should create dependencies outside `untracked()`. See Angular guide: https://angular.dev/guide/signals#reading-without-tracking-dependencies',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-fully-untracked-effect',
+});
+
 const MESSAGE_ID$3 = 'no-href-with-router-link';
 const ERROR_MESSAGE$1 = 'Do not use href and routerLink attributes together on the same element';
 const config$1 = {
@@ -2108,7 +2642,7 @@ const config$1 = {
 };
 
 const createRule$a = ESLintUtils.RuleCreator((name) => name);
-const rule$8 = createRule$a({
+const rule$d = createRule$a({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getClass(node);
@@ -2181,7 +2715,7 @@ function getClass(node) {
 
 const createRule$9 = ESLintUtils.RuleCreator((name) => name);
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$7 = createRule$9({
+const rule$c = createRule$9({
     create(context) {
         return {
             Program(node) {
@@ -2220,7 +2754,7 @@ const rule$7 = createRule$9({
 });
 
 const createRule$8 = ESLintUtils.RuleCreator((name) => name);
-const rule$6 = createRule$8({
+const rule$b = createRule$8({
     create(context) {
         const services = ESLintUtils.getParserServices(context);
         const checker = services.program.getTypeChecker();
@@ -2411,7 +2945,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$5 = createRule$7({
+const rule$a = createRule$7({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -2507,6 +3041,54 @@ const rule$5 = createRule$7({
     name: 'no-redundant-type-annotation',
 });
 
+const rule$9 = createUntrackedRule({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        return {
+            CallExpression(node) {
+                for (const scope of getReactiveScopes(node, program)) {
+                    const reported = new Set();
+                    walkAfterAsyncBoundaryAst(scope.callback, (inner) => {
+                        if (inner.type !== AST_NODE_TYPES.CallExpression ||
+                            !isSignalReadCall(inner, checker, esTreeNodeToTSNodeMap)) {
+                            return;
+                        }
+                        const key = String(inner.range);
+                        if (reported.has(key)) {
+                            return;
+                        }
+                        reported.add(key);
+                        context.report({
+                            data: {
+                                kind: scope.kind,
+                                name: sourceCode.getText(inner),
+                            },
+                            messageId: 'readAfterAwait',
+                            node: inner,
+                        });
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow signal reads that occur after `await` inside reactive callbacks, because Angular no longer tracks them as dependencies',
+            url: ANGULAR_SIGNALS_ASYNC_GUIDE_URL,
+        },
+        messages: {
+            readAfterAwait: '`{{ name }}` is read after `await` inside `{{ kind }}`. Angular only tracks synchronous signal reads, so this dependency will not be tracked. Read it before `await` and store the snapshot. See Angular guide: https://angular.dev/guide/signals#reactive-context-and-async-operations',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-signal-reads-after-await-in-reactive-context',
+});
+
 const createRule$6 = ESLintUtils.RuleCreator((name) => name);
 function isStringLiteral(node) {
     return (node.type === AST_NODE_TYPES.Literal &&
@@ -2571,7 +3153,7 @@ function hasTemplateLiteralAncestor(node) {
     }
     return false;
 }
-const rule$4 = createRule$6({
+const rule$8 = createRule$6({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -2630,49 +3212,620 @@ const rule$4 = createRule$6({
                     return;
                 }
                 context.report({
-                    fix: (fixer) => fixer.replaceText(node, allLiterals
-                        ? buildMergedString(parts)
-                        : `\`${partsToTemplateContent(parts, getText)}\``),
-                    messageId: allLiterals ? 'mergeLiterals' : 'useTemplate',
-                    node,
+                    fix: (fixer) => fixer.replaceText(node, allLiterals
+                        ? buildMergedString(parts)
+                        : `\`${partsToTemplateContent(parts, getText)}\``),
+                    messageId: allLiterals ? 'mergeLiterals' : 'useTemplate',
+                    node,
+                });
+            },
+            TemplateLiteral(node) {
+                // Tagged templates: changing quasis/expressions count alters behaviour
+                if (node.parent.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+                    return;
+                }
+                for (const [i, expr] of node.expressions.entries()) {
+                    if (expr.type === AST_NODE_TYPES.TemplateLiteral &&
+                        expr.parent.type !== AST_NODE_TYPES.TaggedTemplateExpression) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceText(node, `\`${templateContent(node, (e, j) => (j === i ? templateContent(expr, wrapExpr) : wrapExpr(e)))}\``),
+                            messageId: 'flattenTemplate',
+                            node: expr,
+                        });
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow string concatenation. Merge adjacent string literals into one; use template literals for string variables.',
+        },
+        fixable: 'code',
+        messages: {
+            flattenTemplate: 'Flatten nested template literal into its parent.',
+            mergeLiterals: 'Merge string literals instead of concatenating them.',
+            useTemplate: 'Use a template literal instead of string concatenation.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'no-string-literal-concat',
+});
+
+/** Returns the local alias for `untracked` from `@angular/core`, or null if not imported. */
+function findUntrackedAlias(program) {
+    return getLocalNameForImport(program, '@angular/core', 'untracked');
+}
+/**
+ * Builds fixer actions that add `untracked` to an existing `@angular/core` import,
+ * or insert a new import declaration when none exists.
+ */
+function buildUntrackedImportFixes(program, fixer) {
+    const coreImport = findRuntimeAngularCoreImport(program);
+    if (!coreImport) {
+        const firstStatement = program.body[0];
+        if (!firstStatement) {
+            return [];
+        }
+        return [
+            fixer.insertTextBefore(firstStatement, "import { untracked } from '@angular/core';\n"),
+        ];
+    }
+    const namedSpecifiers = coreImport.specifiers.filter((specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier);
+    if (namedSpecifiers.length > 0) {
+        return [
+            fixer.insertTextAfter(namedSpecifiers[namedSpecifiers.length - 1], ', untracked'),
+        ];
+    }
+    const defaultImport = coreImport.specifiers.find((specifier) => specifier.type === AST_NODE_TYPES.ImportDefaultSpecifier);
+    if (defaultImport) {
+        return [fixer.insertTextAfter(defaultImport, ', { untracked }')];
+    }
+    return [
+        fixer.insertTextAfter(coreImport, "\nimport { untracked } from '@angular/core';"),
+    ];
+}
+/**
+ * Removes the `untracked` import specifier from `@angular/core`.
+ * When it is the last specifier, removes the entire declaration.
+ */
+function buildImportRemovalFixes(program, fixer, sourceCode) {
+    const match = findAngularCoreImportSpecifier(program, 'untracked');
+    if (!match) {
+        return [];
+    }
+    const { importDecl, specifier: untrackedSpec } = match;
+    const namedSpecifiers = importDecl.specifiers.filter((s) => s.type === AST_NODE_TYPES.ImportSpecifier);
+    if (importDecl.specifiers.length === 1) {
+        return [fixer.remove(importDecl)];
+    }
+    const importText = sourceCode.getText(importDecl);
+    const importStart = importDecl.range[0];
+    const specStart = untrackedSpec.range[0];
+    const specEnd = untrackedSpec.range[1];
+    // Try to remove a trailing comma
+    const textAfter = importText.slice(specEnd - importStart);
+    const trailingComma = /^(\s*,)/.exec(textAfter);
+    if (trailingComma) {
+        return [fixer.removeRange([specStart, specEnd + trailingComma[1].length])];
+    }
+    // Try to remove a leading comma (last specifier)
+    const textBefore = importText.slice(0, specStart - importStart);
+    const leadingCommaIdx = textBefore.lastIndexOf(',');
+    if (leadingCommaIdx !== -1) {
+        return [fixer.removeRange([importStart + leadingCommaIdx, specEnd])];
+    }
+    if (namedSpecifiers.length === 1) {
+        return [fixer.remove(untrackedSpec)];
+    }
+    return [fixer.remove(untrackedSpec)];
+}
+
+const IMPERATIVE_UNTRACKED_METHODS = new Set(['registerOnChange', 'writeValue']);
+function dedent$1(text, extraSpaces) {
+    if (extraSpaces <= 0) {
+        return text;
+    }
+    const prefix = ' '.repeat(extraSpaces);
+    return text
+        .split('\n')
+        .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
+        .join('\n');
+}
+function isFunctionLike(node) {
+    return (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === AST_NODE_TYPES.FunctionExpression);
+}
+function getObjectPropertyName(node) {
+    if (node.computed) {
+        return null;
+    }
+    if (node.key.type === AST_NODE_TYPES.Identifier) {
+        return node.key.name;
+    }
+    return typeof node.key.value === 'string' ? node.key.value : null;
+}
+function getEnclosingClassMember(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type === AST_NODE_TYPES.MethodDefinition ||
+            current.type === AST_NODE_TYPES.PropertyDefinition) {
+            return current;
+        }
+    }
+    return null;
+}
+function getEnclosingFunction(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (isFunctionLike(current)) {
+            return current;
+        }
+    }
+    return null;
+}
+function getClassMemberName(member) {
+    if (member.key.type === AST_NODE_TYPES.Identifier) {
+        return member.key.name;
+    }
+    if (member.key.type === AST_NODE_TYPES.Literal &&
+        typeof member.key.value === 'string') {
+        return member.key.value;
+    }
+    return null;
+}
+function hasNamedDecorator(node, name) {
+    return node.decorators.some((decorator) => {
+        const expression = decorator.expression;
+        if (expression.type === AST_NODE_TYPES.Identifier) {
+            return expression.name === name;
+        }
+        return (expression.type === AST_NODE_TYPES.CallExpression &&
+            expression.callee.type === AST_NODE_TYPES.Identifier &&
+            expression.callee.name === name);
+    });
+}
+function isPipeTransformMember(member) {
+    if (getClassMemberName(member) !== 'transform') {
+        return false;
+    }
+    return hasNamedDecorator(member.parent.parent, 'Pipe');
+}
+function isAllowedImperativeAngularContext(node) {
+    const member = getEnclosingClassMember(node);
+    const memberName = member ? getClassMemberName(member) : null;
+    if (!member || !memberName) {
+        return false;
+    }
+    return IMPERATIVE_UNTRACKED_METHODS.has(memberName) || isPipeTransformMember(member);
+}
+function isDirectCallbackArgument(fn) {
+    const parent = fn.parent;
+    if (fn.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+        fn.type !== AST_NODE_TYPES.FunctionExpression) {
+        return false;
+    }
+    return ((parent.type === AST_NODE_TYPES.CallExpression ||
+        parent.type === AST_NODE_TYPES.NewExpression) &&
+        parent.arguments.includes(fn));
+}
+function getScopeRoot(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type === AST_NODE_TYPES.Program || isFunctionLike(current)) {
+            return current;
+        }
+    }
+    return node;
+}
+function isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap) {
+    const parent = fn.parent;
+    if (parent.type !== AST_NODE_TYPES.VariableDeclarator ||
+        parent.id.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    const id = parent.id;
+    const tsNode = esTreeNodeToTSNodeMap.get(id);
+    if (!tsNode) {
+        return false;
+    }
+    const symbol = checker.getSymbolAtLocation(tsNode);
+    if (!symbol) {
+        return false;
+    }
+    let found = false;
+    const scopeRoot = getScopeRoot(parent);
+    walkAst(scopeRoot, (node) => {
+        if (node.type !== AST_NODE_TYPES.Identifier ||
+            node === id ||
+            node.name !== id.name) {
+            return;
+        }
+        const referenceTsNode = esTreeNodeToTSNodeMap.get(node);
+        const referenceSymbol = referenceTsNode
+            ? checker.getSymbolAtLocation(referenceTsNode)
+            : null;
+        if (referenceSymbol !== symbol) {
+            return;
+        }
+        const usageParent = node.parent;
+        if ((usageParent.type === AST_NODE_TYPES.CallExpression ||
+            usageParent.type === AST_NODE_TYPES.NewExpression) &&
+            usageParent.arguments.includes(node)) {
+            found = true;
+            return false;
+        }
+        return;
+    });
+    return found;
+}
+function isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap) {
+    const [arg] = node.arguments;
+    if (!arg ||
+        arg.type === AST_NODE_TYPES.SpreadElement ||
+        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+        return false;
+    }
+    const fn = getEnclosingFunction(node);
+    if (!fn) {
+        return false;
+    }
+    return (isDirectCallbackArgument(fn) ||
+        isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap));
+}
+function isAngularInjectionTokenFactoryFunction(fn, program) {
+    const parent = fn.parent;
+    const injectionTokenName = getLocalNameForImport(program, '@angular/core', 'InjectionToken');
+    if (!injectionTokenName ||
+        parent.type !== AST_NODE_TYPES.Property ||
+        getObjectPropertyName(parent) !== 'factory') {
+        return false;
+    }
+    const objectExpression = parent.parent;
+    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
+        objectExpression.parent.type === AST_NODE_TYPES.NewExpression &&
+        objectExpression.parent.arguments.includes(objectExpression) &&
+        objectExpression.parent.callee.type === AST_NODE_TYPES.Identifier &&
+        objectExpression.parent.callee.name === injectionTokenName);
+}
+function isAngularUseFactoryFunction(fn) {
+    const parent = fn.parent;
+    if (parent.type !== AST_NODE_TYPES.Property ||
+        getObjectPropertyName(parent) !== 'useFactory') {
+        return false;
+    }
+    const objectExpression = parent.parent;
+    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
+        objectExpression.properties.some((property) => property.type === AST_NODE_TYPES.Property &&
+            getObjectPropertyName(property) === 'provide'));
+}
+function isReactiveOwnerCall(node, program) {
+    return (node.type === AST_NODE_TYPES.CallExpression &&
+        getReactiveScopes(node, program).length > 0);
+}
+function getFixableReactiveCall(node, program) {
+    const [arg] = node.arguments;
+    if (!arg ||
+        arg.type === AST_NODE_TYPES.SpreadElement ||
+        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+        return null;
+    }
+    if (isReactiveOwnerCall(arg.body, program)) {
+        return arg.body;
+    }
+    if (arg.body.type !== AST_NODE_TYPES.BlockStatement || arg.body.body.length !== 1) {
+        return null;
+    }
+    const [statement] = arg.body.body;
+    if (statement?.type === AST_NODE_TYPES.ReturnStatement &&
+        statement.argument &&
+        isReactiveOwnerCall(statement.argument, program)) {
+        return statement.argument;
+    }
+    if (node.parent.type === AST_NODE_TYPES.ExpressionStatement &&
+        statement?.type === AST_NODE_TYPES.ExpressionStatement &&
+        isReactiveOwnerCall(statement.expression, program)) {
+        return statement.expression;
+    }
+    return null;
+}
+function isAllowedLazyAngularFactoryContext(node, program) {
+    const fn = getEnclosingFunction(node);
+    if (!fn || !getFixableReactiveCall(node, program)) {
+        return false;
+    }
+    return (isAngularInjectionTokenFactoryFunction(fn, program) ||
+        isAngularUseFactoryFunction(fn));
+}
+function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCode) {
+    const text = sourceCode.getText(reactiveCall);
+    if (reactiveCall.parent.type !== AST_NODE_TYPES.ExpressionStatement ||
+        outerUntrackedCall.parent.type !== AST_NODE_TYPES.ExpressionStatement) {
+        return text;
+    }
+    return dedent$1(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
+}
+const rule$7 = createUntrackedRule({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        const getUntrackedLocalName = () => findUntrackedAlias(program);
+        function isUntrackedUsedElsewhere(localName, excludeNode) {
+            let found = false;
+            walkAst(program, (node) => {
+                if (node.type === AST_NODE_TYPES.CallExpression &&
+                    node !== excludeNode &&
+                    node.callee.type === AST_NODE_TYPES.Identifier &&
+                    node.callee.name === localName) {
+                    found = true;
+                    return false;
+                }
+                return;
+            });
+            return found;
+        }
+        return {
+            CallExpression(node) {
+                if (!isAngularUntrackedCall(node, program)) {
+                    return;
+                }
+                if (findEnclosingReactiveScope(node, program)) {
+                    return;
+                }
+                if (isAllowedImperativeAngularContext(node)) {
+                    return;
+                }
+                if (isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap)) {
+                    return;
+                }
+                if (isAllowedLazyAngularFactoryContext(node, program)) {
+                    return;
+                }
+                const reactiveCall = getFixableReactiveCall(node, program);
+                context.report({
+                    fix: reactiveCall
+                        ? (fixer) => {
+                            const fixes = [
+                                fixer.replaceText(node, buildReactiveCallReplacement(node, reactiveCall, sourceCode)),
+                            ];
+                            const untrackedLocalName = getUntrackedLocalName();
+                            const stillUsed = untrackedLocalName !== null &&
+                                isUntrackedUsedElsewhere(untrackedLocalName, node);
+                            if (!stillUsed) {
+                                fixes.push(...buildImportRemovalFixes(program, fixer, sourceCode));
+                            }
+                            return fixes;
+                        }
+                        : undefined,
+                    messageId: 'outsideReactiveContext',
+                    node: node.callee.type === AST_NODE_TYPES.Identifier
+                        ? node.callee
+                        : node,
                 });
             },
-            TemplateLiteral(node) {
-                // Tagged templates: changing quasis/expressions count alters behaviour
-                if (node.parent.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow `untracked()` outside the synchronous body of a reactive callback, except for supported imperative Angular hooks, deferred callback wrappers, and lazy DI factories that may execute under an ambient reactive context',
+            url: ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL,
+        },
+        fixable: 'code',
+        messages: {
+            outsideReactiveContext: '`untracked()` is used outside the synchronous body of a reactive callback and outside the supported imperative/deferred/lazy-factory exceptions, so it does not prevent dependency tracking and only adds noise. Remove it. See Angular guide: https://angular.dev/guide/signals#reading-without-tracking-dependencies',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-untracked-outside-reactive-context',
+});
+
+/**
+ * Removes `extraSpaces` leading spaces from every line of `text` that starts
+ * with at least that many spaces.
+ */
+function dedent(text, extraSpaces) {
+    if (extraSpaces <= 0) {
+        return text;
+    }
+    const prefix = ' '.repeat(extraSpaces);
+    return text
+        .split('\n')
+        .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
+        .join('\n');
+}
+/**
+ * Builds the replacement text for the parent ExpressionStatement of an
+ * `untracked(...)` call.
+ *
+ * - Block body: extracts inner statements and re-indents them to match the
+ *   parent ExpressionStatement's indentation.
+ * - Expression body: returns `<expr>;` (no trailing double-semicolon).
+ *
+ * Returns null if the untracked argument is not a function expression.
+ */
+function buildReplacement(untrackedCall, parentStatement, sourceCode) {
+    const [arg] = untrackedCall.arguments;
+    if (!arg ||
+        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+        return null;
+    }
+    const { body } = arg;
+    if (body.type === AST_NODE_TYPES.BlockStatement) {
+        const { body: stmts } = body;
+        if (stmts.length === 0) {
+            return null; // Nothing to replace with — let caller delete the statement
+        }
+        const parentColumn = parentStatement.loc.start.column;
+        const firstStmtColumn = stmts[0].loc.start.column;
+        const extra = firstStmtColumn - parentColumn;
+        const indented = stmts.map((s) => dedent(sourceCode.getText(s), extra));
+        return indented.join(`\n${''.padStart(parentColumn)}`);
+    }
+    // Expression body: arrow `() => expr` — just emit `expr;`
+    return `${sourceCode.getText(body)};`;
+}
+function getAllCallExpressions(root) {
+    const result = [];
+    walkAst(root, (node) => {
+        if (node.type === AST_NODE_TYPES.CallExpression) {
+            result.push(node);
+        }
+    });
+    return result;
+}
+function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program) {
+    let found = false;
+    walkSynchronousAst(root, (node) => {
+        if (node.type === AST_NODE_TYPES.MemberExpression) {
+            if (isGetterMemberAccess(node, checker, esTreeNodeToTSNodeMap)) {
+                found = true;
+                return false;
+            }
+            return;
+        }
+        if (node.type !== AST_NODE_TYPES.CallExpression) {
+            return;
+        }
+        if (isAngularUntrackedCall(node, program) ||
+            isSignalReadCall(node, checker, esTreeNodeToTSNodeMap) ||
+            isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap)) {
+            return;
+        }
+        found = true;
+        return false;
+    });
+    return found;
+}
+const rule$6 = createUntrackedRule({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        const getUntrackedLocalName = () => getLocalNameForImport(program, '@angular/core', 'untracked');
+        function isUntrackedUsedElsewhere(localName, excludeNode) {
+            return getAllCallExpressions(program).some((n) => n !== excludeNode &&
+                n.callee.type === AST_NODE_TYPES.Identifier &&
+                n.callee.name === localName);
+        }
+        function checkUntrackedCall(untrackedCall, kind) {
+            const [arg] = untrackedCall.arguments;
+            if (!arg ||
+                (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+                    arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+                return;
+            }
+            const { reads } = collectSignalUsages(arg, checker, esTreeNodeToTSNodeMap, program);
+            if (reads.length > 0) {
+                // Snapshot reads inside reactive callbacks are a valid Angular
+                // pattern even when the snapshot later influences branching.
+                return;
+            }
+            if (hasOpaqueSynchronousCalls(arg, checker, esTreeNodeToTSNodeMap, program)) {
+                return;
+            }
+            // Only fix when the parent is a plain ExpressionStatement so we can
+            // replace statement-for-statement without breaking surrounding structure.
+            const parent = untrackedCall.parent;
+            const canFix = parent.type === AST_NODE_TYPES.ExpressionStatement;
+            context.report({
+                data: { kind },
+                fix: canFix
+                    ? (fixer) => {
+                        const parentStmt = parent;
+                        const replacement = buildReplacement(untrackedCall, parentStmt, sourceCode);
+                        if (replacement === null) {
+                            return null;
+                        }
+                        const untrackedLocalName = getUntrackedLocalName();
+                        const stillUsed = untrackedLocalName !== null &&
+                            isUntrackedUsedElsewhere(untrackedLocalName, untrackedCall);
+                        const fixes = [fixer.replaceText(parentStmt, replacement)];
+                        if (!stillUsed) {
+                            fixes.push(...buildImportRemovalFixes(program, fixer, sourceCode));
+                        }
+                        return fixes;
+                    }
+                    : undefined,
+                messageId: 'uselessUntracked',
+                node: untrackedCall,
+            });
+        }
+        function walkForUntracked(root, kind) {
+            walkSynchronousAst(root, (node) => {
+                if (node.type !== AST_NODE_TYPES.CallExpression ||
+                    !isAngularUntrackedCall(node, program)) {
                     return;
                 }
-                for (const [i, expr] of node.expressions.entries()) {
-                    if (expr.type === AST_NODE_TYPES.TemplateLiteral &&
-                        expr.parent.type !== AST_NODE_TYPES.TaggedTemplateExpression) {
-                        context.report({
-                            fix: (fixer) => fixer.replaceText(node, `\`${templateContent(node, (e, j) => (j === i ? templateContent(expr, wrapExpr) : wrapExpr(e)))}\``),
-                            messageId: 'flattenTemplate',
-                            node: expr,
-                        });
-                    }
+                checkUntrackedCall(node, kind);
+                // Do not descend — nested untracked bodies are separate scopes
+                return false;
+            });
+        }
+        return {
+            CallExpression(node) {
+                for (const scope of getReactiveScopes(node, program)) {
+                    walkForUntracked(scope.callback, scope.kind);
                 }
             },
         };
     },
     meta: {
         docs: {
-            description: 'Disallow string concatenation. Merge adjacent string literals into one; use template literals for string variables.',
+            description: 'Disallow `untracked()` wrappers inside reactive callbacks when they contain no signal reads and do not wrap opaque external code that may read signals',
+            url: ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL,
         },
         fixable: 'code',
         messages: {
-            flattenTemplate: 'Flatten nested template literal into its parent.',
-            mergeLiterals: 'Merge string literals instead of concatenating them.',
-            useTemplate: 'Use a template literal instead of string concatenation.',
+            uselessUntracked: 'This `untracked()` wrapper is unnecessary inside `{{ kind }}` because its callback contains no signal reads that need shielding from dependency tracking. Pure writes (`.set()`, `.update()`, `.mutate()`) do not require `untracked()`. See Angular guide: https://angular.dev/guide/signals#reading-without-tracking-dependencies',
         },
         schema: [],
         type: 'suggestion',
     },
-    name: 'no-string-literal-concat',
+    name: 'no-useless-untracked',
 });
 
+/**
+ * Strips TypeScript-only wrapper nodes that have no runtime meaning:
+ * `as` casts, non-null assertions (`!`), type assertions (`<T>expr`), and
+ * optional-chain wrappers. Iterates until no more wrappers are found.
+ */
+function unwrapExpression(expression) {
+    let current = expression;
+    let didUnwrap = true;
+    while (didUnwrap) {
+        didUnwrap = false;
+        switch (current.type) {
+            case AST_NODE_TYPES.ChainExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case AST_NODE_TYPES.TSAsExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case AST_NODE_TYPES.TSNonNullExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+        }
+    }
+    return current;
+}
+
 const createRule$5 = ESLintUtils.RuleCreator((name) => name);
-const rule$3 = createRule$5({
+const rule$5 = createRule$5({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
@@ -2712,32 +3865,6 @@ const rule$3 = createRule$5({
             const [onlyProperty] = node.properties;
             return onlyProperty ? !isForbiddenProperty(onlyProperty) : false;
         };
-        const unwrapExpression = (expression) => {
-            let current = expression;
-            let didUnwrap = true;
-            while (didUnwrap) {
-                didUnwrap = false;
-                switch (current.type) {
-                    case AST_NODE_TYPES$1.ChainExpression:
-                        current = current.expression;
-                        didUnwrap = true;
-                        break;
-                    case AST_NODE_TYPES$1.TSAsExpression:
-                        current = current.expression;
-                        didUnwrap = true;
-                        break;
-                    case AST_NODE_TYPES$1.TSNonNullExpression:
-                        current = current.expression;
-                        didUnwrap = true;
-                        break;
-                    case AST_NODE_TYPES$1.TSTypeAssertion:
-                        current = current.expression;
-                        didUnwrap = true;
-                        break;
-                }
-            }
-            return current;
-        };
         const getParenthesizedInner = (expression) => {
             const anyExpression = expression;
             if (anyExpression?.type === 'ParenthesizedExpression') {
@@ -3316,7 +4443,7 @@ function getPushCall(node) {
     }
     return call;
 }
-const rule$2 = createRule$3({
+const rule$4 = createRule$3({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -3394,6 +4521,398 @@ const rule$2 = createRule$3({
     name: 'prefer-multi-arg-push',
 });
 
+/**
+ * prefer-untracked-incidental-signal-reads
+ *
+ * Conservatively flags signal reads inside reactive callbacks that appear to be
+ * incidental — they provide only a snapshot value passed to a side-effecting
+ * consumer such as a signal write or DOM imperative call — and therefore
+ * probably should be wrapped in `untracked(...)`.
+ *
+ * Design principle: prefer false-negatives over false-positives.
+ * This rule only reports patterns it can confidently identify as suspicious.
+ *
+ * Limitations
+ * -----------
+ * Whether a signal read *should* be tracked is a question of developer intent,
+ * not syntax. The rule relies on heuristics (type-based signal detection,
+ * structural pattern matching) and will inevitably produce:
+ *
+ *  - False negatives: incidental reads that do not match the heuristics.
+ *  - False positives (rare): reads that look incidental but are intentional
+ *    dependencies (e.g. the developer intentionally re-runs the effect when
+ *    `mousePosition` changes to keep `position` in sync).
+ *
+ * Always review suggestions before accepting the fix. If the reported read
+ * IS meant to be a tracked dependency, disable the rule for that line.
+ */
+const CONSOLE_METHODS = new Set([
+    'assert',
+    'debug',
+    'dir',
+    'dirxml',
+    'error',
+    'group',
+    'groupCollapsed',
+    'groupEnd',
+    'info',
+    'log',
+    'table',
+    'trace',
+    'warn',
+]);
+const HIGH_CONFIDENCE_DOM_METHODS = new Set(['requestFullscreen']);
+const LIB_DOM_FILE_PATTERN = /(?:^|[\\/])lib\.dom(?:\.[^\\/]+)?\.d\.ts$/;
+/** Returns the source text for `untracked(() => signalGetter())`. */
+function buildUntrackedWrap(expr, sourceCode, untrackedAlias) {
+    return `${untrackedAlias}(() => ${sourceCode.getText(expr.callee)}())`;
+}
+function unwrapUsageExpression(node) {
+    let current = node;
+    while (current.parent &&
+        (current.parent.type === AST_NODE_TYPES.ChainExpression ||
+            current.parent.type === AST_NODE_TYPES.TSAsExpression ||
+            current.parent.type === AST_NODE_TYPES.TSNonNullExpression ||
+            current.parent.type === AST_NODE_TYPES.TSTypeAssertion)) {
+        current = current.parent;
+    }
+    return current;
+}
+function isNodeInside(node, ancestor) {
+    for (let current = node; current; current = current.parent) {
+        if (current === ancestor) {
+            return true;
+        }
+    }
+    return false;
+}
+function isNodeInsideAny(node, ancestors) {
+    return ancestors.some((ancestor) => isNodeInside(node, ancestor));
+}
+function isStatementPositionCall(node) {
+    const usage = unwrapUsageExpression(node);
+    if (usage.parent?.type === AST_NODE_TYPES.ExpressionStatement) {
+        return true;
+    }
+    return (usage.parent?.type === AST_NODE_TYPES.AwaitExpression &&
+        usage.parent.parent.type === AST_NODE_TYPES.ExpressionStatement);
+}
+function isConsoleMethodCall(node) {
+    if (node.callee.type !== AST_NODE_TYPES.MemberExpression ||
+        node.callee.object.type !== AST_NODE_TYPES.Identifier ||
+        node.callee.object.name !== 'console' ||
+        node.callee.property.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return CONSOLE_METHODS.has(node.callee.property.name);
+}
+function isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap) {
+    if (node.callee.type === AST_NODE_TYPES.MemberExpression &&
+        node.callee.property.type === AST_NODE_TYPES.Identifier &&
+        HIGH_CONFIDENCE_DOM_METHODS.has(node.callee.property.name)) {
+        return true;
+    }
+    const tsNode = esTreeNodeToTSNodeMap.get(node);
+    if (!tsNode) {
+        return false;
+    }
+    const signature = checker.getResolvedSignature(tsNode);
+    const declaration = signature?.declaration;
+    if (!declaration) {
+        return false;
+    }
+    if (!LIB_DOM_FILE_PATTERN.test(declaration.getSourceFile().fileName)) {
+        return false;
+    }
+    const returnType = checker.typeToString(checker.getReturnTypeOfSignature(signature));
+    return returnType === 'void' || returnType === 'Promise<void>';
+}
+function isSuspiciousDomCallArgumentConsumer(node, checker, esTreeNodeToTSNodeMap, program) {
+    if (isAngularUntrackedCall(node, program) ||
+        isSignalReadCall(node, checker, esTreeNodeToTSNodeMap) ||
+        isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap) ||
+        !isStatementPositionCall(node) ||
+        isConsoleMethodCall(node)) {
+        return false;
+    }
+    return isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap);
+}
+function isAliasDeclarationIdentifier(node) {
+    return (node.type === AST_NODE_TYPES.Identifier &&
+        node.parent.type === AST_NODE_TYPES.VariableDeclarator &&
+        node.parent.id === node);
+}
+function aliasHasExternalUsage(alias, consumers, scope, checker, esTreeNodeToTSNodeMap) {
+    const tsNode = esTreeNodeToTSNodeMap.get(alias);
+    if (!tsNode) {
+        return false;
+    }
+    const symbol = checker.getSymbolAtLocation(tsNode);
+    if (!symbol) {
+        return false;
+    }
+    let usedOutsideConsumers = false;
+    walkSynchronousAst(scope.callback, (node) => {
+        if (node.type !== AST_NODE_TYPES.Identifier ||
+            node === alias ||
+            isAliasDeclarationIdentifier(node) ||
+            isNodeInsideAny(node, consumers)) {
+            return;
+        }
+        const referenceTsNode = esTreeNodeToTSNodeMap.get(node);
+        const referenceSymbol = referenceTsNode
+            ? checker.getSymbolAtLocation(referenceTsNode)
+            : null;
+        if (referenceSymbol !== symbol) {
+            return;
+        }
+        usedOutsideConsumers = true;
+        return false;
+    });
+    return usedOutsideConsumers;
+}
+/**
+ * Collects all signal reads that appear as direct arguments to a high-confidence
+ * incidental-read consumer inside a reactive scope, such as a writable-signal
+ * write method or a DOM side-effect call in statement position.
+ *
+ * Only the topmost, direct argument reads are considered suspicious.
+ * Nested reads (e.g. inside ternaries, function calls) are skipped because
+ * they are harder to reason about safely.
+ */
+function resolveSignalReadAlias(expression, context, seen = new Set()) {
+    const unwrapped = unwrapExpression(expression);
+    if (unwrapped.type === AST_NODE_TYPES.CallExpression &&
+        isSignalReadCall(unwrapped, context.checker, context.esTreeNodeToTSNodeMap)) {
+        return unwrapped;
+    }
+    if (unwrapped.type !== AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    const tsNode = context.esTreeNodeToTSNodeMap.get(unwrapped);
+    if (!tsNode) {
+        return null;
+    }
+    const symbol = context.checker.getSymbolAtLocation(tsNode);
+    if (!symbol) {
+        return null;
+    }
+    const symbolId = `${symbol.name}:${symbol.declarations?.[0]?.pos ?? -1}`;
+    if (seen.has(symbolId)) {
+        return null;
+    }
+    seen.add(symbolId);
+    for (const declaration of symbol.declarations ?? []) {
+        const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
+        if (estreeDeclaration?.type !== AST_NODE_TYPES.VariableDeclarator) {
+            continue;
+        }
+        const variableDeclaration = estreeDeclaration.parent;
+        if (variableDeclaration.kind !== 'const' ||
+            !estreeDeclaration.init ||
+            estreeDeclaration.range[0] > unwrapped.range[0] ||
+            !isNodeInsideSynchronousReactiveScope(estreeDeclaration, context.scope.callback)) {
+            continue;
+        }
+        const initializer = unwrapExpression(estreeDeclaration.init);
+        if (initializer.type === AST_NODE_TYPES.CallExpression &&
+            isSignalReadCall(initializer, context.checker, context.esTreeNodeToTSNodeMap)) {
+            return initializer;
+        }
+        if (initializer.type === AST_NODE_TYPES.Identifier) {
+            return resolveSignalReadAlias(initializer, context, seen);
+        }
+    }
+    return null;
+}
+function collectSuspiciousReads(scope, checker, esTreeNodeToTSNodeMap, tsNodeToESTreeNodeMap, program) {
+    const suspicious = new Map();
+    const aliasResolutionContext = {
+        checker,
+        esTreeNodeToTSNodeMap,
+        scope,
+        tsNodeToESTreeNodeMap,
+    };
+    walkSynchronousAst(scope.callback, (node) => {
+        if (node.type !== AST_NODE_TYPES.CallExpression) {
+            return;
+        }
+        // Skip already-untracked scopes
+        if (isAngularUntrackedCall(node, program)) {
+            return false;
+        }
+        if (!isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap) &&
+            !isSuspiciousDomCallArgumentConsumer(node, checker, esTreeNodeToTSNodeMap, program)) {
+            return;
+        }
+        // Inspect each direct argument of the consumer call for signal reads.
+        // We intentionally do NOT recurse into nested expressions —
+        // only top-level direct reads in the argument position are flagged.
+        for (const arg of node.arguments) {
+            if (arg.type === AST_NODE_TYPES.SpreadElement) {
+                continue;
+            }
+            const read = resolveSignalReadAlias(arg, aliasResolutionContext);
+            const unwrappedArg = unwrapExpression(arg);
+            if (read) {
+                const key = String(read.range);
+                const existing = suspicious.get(key);
+                const alias = unwrappedArg.type === AST_NODE_TYPES.Identifier ? unwrappedArg : null;
+                if (existing) {
+                    if (!existing.consumers.includes(node)) {
+                        existing.consumers.push(node);
+                    }
+                    if (alias && !existing.aliases.includes(alias)) {
+                        existing.aliases.push(alias);
+                    }
+                }
+                else {
+                    suspicious.set(key, {
+                        aliases: alias ? [alias] : [],
+                        consumers: [node],
+                        read,
+                    });
+                }
+            }
+        }
+        return false;
+    });
+    return [...suspicious.values()];
+}
+const rule$3 = createUntrackedRule({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const tsNodeToESTreeNodeMap = parserServices.tsNodeToESTreeNodeMap;
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        function buildFix(read) {
+            const untrackedAlias = findUntrackedAlias(program);
+            const alreadyHasUntracked = untrackedAlias !== null;
+            const wrapped = buildUntrackedWrap(read, sourceCode, untrackedAlias ?? 'untracked');
+            if (alreadyHasUntracked) {
+                return (fixer) => [fixer.replaceText(read, wrapped)];
+            }
+            return (fixer) => [
+                fixer.replaceText(read, wrapped),
+                ...buildUntrackedImportFixes(program, fixer),
+            ];
+        }
+        return {
+            CallExpression(node) {
+                for (const scope of getReactiveScopes(node, program)) {
+                    const suspicious = collectSuspiciousReads(scope, checker, esTreeNodeToTSNodeMap, tsNodeToESTreeNodeMap, program);
+                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    const suspiciousReads = new Set(suspicious.map(({ read }) => read));
+                    for (const { aliases, consumers, read } of suspicious) {
+                        const hasTrackedDependency = consumers.some((consumer) => trackedReads.some((trackedRead) => !suspiciousReads.has(trackedRead) &&
+                            !isNodeInside(trackedRead, consumer)));
+                        const hasExternalAliasUsage = aliases.some((alias) => aliasHasExternalUsage(alias, consumers, scope, checker, esTreeNodeToTSNodeMap));
+                        if (!hasTrackedDependency || hasExternalAliasUsage) {
+                            continue;
+                        }
+                        context.report({
+                            data: { kind: scope.kind, name: sourceCode.getText(read) },
+                            fix: buildFix(read),
+                            messageId: 'incidentalRead',
+                            node: read,
+                        });
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Suggest wrapping likely-incidental signal reads with `untracked()` when they are used only as snapshot values in reactive callbacks that already have another tracked dependency, such as writable-signal writes or DOM side-effect calls',
+            url: ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL,
+        },
+        fixable: 'code',
+        messages: {
+            incidentalRead: '`{{ name }}` looks like an incidental signal read inside `{{ kind }}`. If it is only providing a snapshot value and should not trigger a re-run, wrap it with `untracked()`. See Angular guide: https://angular.dev/guide/signals#reading-without-tracking-dependencies',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'prefer-untracked-incidental-signal-reads',
+});
+
+function getReturnedExpression(node) {
+    if (node.body.type !== AST_NODE_TYPES.BlockStatement) {
+        return unwrapExpression(node.body);
+    }
+    if (node.body.body.length !== 1) {
+        return null;
+    }
+    const statement = node.body.body[0];
+    if (statement?.type !== AST_NODE_TYPES.ReturnStatement || !statement.argument) {
+        return null;
+    }
+    return unwrapExpression(statement.argument);
+}
+function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
+    const [arg] = node.arguments;
+    if (!arg || arg.type === AST_NODE_TYPES.SpreadElement) {
+        return null;
+    }
+    if (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+        arg.type !== AST_NODE_TYPES.FunctionExpression) {
+        return null;
+    }
+    const body = getReturnedExpression(arg);
+    if (body?.type !== AST_NODE_TYPES.CallExpression) {
+        return null;
+    }
+    if (!isSignalReadCall(body, checker, esTreeNodeToTSNodeMap)) {
+        return null;
+    }
+    const getter = unwrapExpression(body.callee);
+    if (getter.type === AST_NODE_TYPES.MemberExpression &&
+        isGetterMemberAccess(getter, checker, esTreeNodeToTSNodeMap)) {
+        return null;
+    }
+    return isSignalType(getter, checker, esTreeNodeToTSNodeMap) ? body.callee : null;
+}
+const rule$2 = createUntrackedRule({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        return {
+            CallExpression(node) {
+                if (!isAngularUntrackedCall(node, program)) {
+                    return;
+                }
+                const getter = getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap);
+                if (!getter) {
+                    return;
+                }
+                context.report({
+                    fix: (fixer) => fixer.replaceText(node, `${sourceCode.getText(node.callee)}(${sourceCode.getText(getter)})`),
+                    messageId: 'preferGetterForm',
+                    node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Prefer `untracked(signalGetter)` over `untracked(() => signalGetter())` for a single signal getter',
+            url: ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL,
+        },
+        fixable: 'code',
+        messages: {
+            preferGetterForm: 'Pass single signal getters directly as `untracked(signalGetter)` instead of wrapping them in `untracked(() => signalGetter())`. See Angular guide: https://angular.dev/guide/signals#reading-without-tracking-dependencies',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'prefer-untracked-signal-getter',
+});
+
 function getImportedName(spec) {
     if (spec.imported.type === AST_NODE_TYPES.Identifier) {
         return spec.imported.name;
@@ -3869,19 +5388,25 @@ const plugin = {
         'decorator-key-sort': config$3,
         'flat-exports': flatExports,
         'html-logical-properties': config$2,
-        'injection-token-description': rule$a,
-        'no-deep-imports': rule$9,
+        'injection-token-description': rule$g,
+        'no-deep-imports': rule$f,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
+        'no-fully-untracked-effect': rule$e,
         'no-href-with-router-link': config$1,
-        'no-implicit-public': rule$8,
-        'no-legacy-peer-deps': rule$7,
-        'no-playwright-empty-fill': rule$6,
+        'no-implicit-public': rule$d,
+        'no-legacy-peer-deps': rule$c,
+        'no-playwright-empty-fill': rule$b,
         'no-project-as-in-ng-template': config,
-        'no-redundant-type-annotation': rule$5,
-        'no-string-literal-concat': rule$4,
-        'object-single-line': rule$3,
+        'no-redundant-type-annotation': rule$a,
+        'no-signal-reads-after-await-in-reactive-context': rule$9,
+        'no-string-literal-concat': rule$8,
+        'no-untracked-outside-reactive-context': rule$7,
+        'no-useless-untracked': rule$6,
+        'object-single-line': rule$5,
         'prefer-deep-imports': preferDeepImports,
-        'prefer-multi-arg-push': rule$2,
+        'prefer-multi-arg-push': rule$4,
+        'prefer-untracked-incidental-signal-reads': rule$3,
+        'prefer-untracked-signal-getter': rule$2,
         'short-tui-imports': rule$1,
         'standalone-imports-sort': standaloneImportsSort,
         'strict-tui-doc-example': rule,