@starci/hfs 4.11.21 → 4.12.0

package/runtime/scripts/hfs/rules/unused-symbol-ledger.mjs

@@ -4,74 +4,95 @@
 import { isPlainObject } from '../../../engine/plain-object.mjs';
 import { parseYaml } from '../../../engine/yaml.mjs';
 import { found, readText } from './read.mjs';
-
 const LEDGER_FILE = 'i18n-dynamic-keys.yaml';
 export const LEDGER_SCHEMA = 'starci/i18n-dynamic-keys@1';
 const CODE = 'HFS_UNUSED_SYMBOL';
 const MATCHERS = ['key', 'prefix', 'suffix'];
 const FIELDS = new Set([...MATCHERS, 'reason']);
 const SIDES = new Set(['fe', 'be']);
-const text = value => typeof value === 'string' && value.trim() !== '';
-const describe = entry => `${entry.kind} ${JSON.stringify(entry.value)}`;
-
+const text = (value) => typeof value === 'string' && value.trim() !== '';
+const describe = (entry) => `${entry.kind} ${JSON.stringify(entry.value)}`;
 /** The catalog namespace (the dotted path before the leaf; '' when none) and the leaf of a candidate name. */
 function splitCatalogName(name) {
-  const at = name.lastIndexOf('.');
-  return at < 0 ? { namespace: '', leaf: name } : { namespace: name.slice(0, at), leaf: name.slice(at + 1) };
+    const at = name.lastIndexOf('.');
+    return at < 0 ? { namespace: '', leaf: name } : { namespace: name.slice(0, at), leaf: name.slice(at + 1) };
 }
-
 const MATCH = { key: (leaf, value) => leaf === value, prefix: (leaf, value) => leaf.startsWith(value), suffix: (leaf, value) => leaf.endsWith(value) };
 const matches = (entry, leaf) => MATCH[entry.kind](leaf, entry.value);
-
 function entryProblem(entry) {
-  if (!isPlainObject(entry)) return 'is not a mapping';
-  const unknown = Object.keys(entry).filter(field => !FIELDS.has(field));
-  if (unknown.length) return `has unknown field ${unknown.map(field => JSON.stringify(field)).join(', ')} (allowed: key, prefix, suffix, reason)`;
-  const given = MATCHERS.filter(field => field in entry);
-  if (given.length !== 1) return `must have exactly one of key, prefix or suffix (has ${given.length ? given.join(' and ') : 'none'})`;
-  if (!text(entry[given[0]])) return `${given[0]} must be a non-empty string`;
-  if (!text(entry.reason)) return 'must have a non-empty string reason';
-  return null;
+    if (!isPlainObject(entry))
+        return 'is not a mapping';
+    const unknown = Object.keys(entry).filter(field => !FIELDS.has(field));
+    if (unknown.length)
+        return `has unknown field ${unknown.map(field => JSON.stringify(field)).join(', ')} (allowed: key, prefix, suffix, reason)`;
+    const given = MATCHERS.filter(field => field in entry);
+    if (given.length !== 1)
+        return `must have exactly one of key, prefix or suffix (has ${given.length ? given.join(' and ') : 'none'})`;
+    if (!text(entry[given[0]]))
+        return `${given[0]} must be a non-empty string`;
+    if (!text(entry.reason))
+        return 'must have a non-empty string reason';
+    return null;
 }
-
 /** Parse the ledger text: `{ entries, problems }`; a problem is one precise message about the file's shape. */
 function parseLedger(source) {
-  let doc;
-  try { doc = parseYaml(source); } catch { return { entries: [], problems: ['is not valid YAML'] }; }
-  if (!isPlainObject(doc)) return { entries: [], problems: ['must be a mapping with schema and namespaces'] };
-  const problems = [];
-  for (const field of Object.keys(doc)) if (!['schema', 'namespaces'].includes(field)) problems.push(`has unknown top-level field ${JSON.stringify(field)}`);
-  if (doc.schema !== LEDGER_SCHEMA) problems.push(`schema must be ${LEDGER_SCHEMA}`);
-  if (!isPlainObject(doc.namespaces)) { problems.push('namespaces must be a mapping of namespace to a list of entries'); return { entries: [], problems }; }
-  const entries = [];
-  for (const [namespace, list] of Object.entries(doc.namespaces)) {
-    if (!Array.isArray(list)) { problems.push(`namespace ${JSON.stringify(namespace)} must be a list of entries`); continue; }
-    list.forEach((entry, index) => {
-      const problem = entryProblem(entry);
-      if (problem) { problems.push(`namespace ${JSON.stringify(namespace)} entry ${index + 1} ${problem}`); return; }
-      const kind = MATCHERS.find(field => field in entry);
-      entries.push({ namespace, kind, value: entry[kind] });
-    });
-  }
-  return { entries, problems };
+    let doc;
+    try {
+        doc = parseYaml(source);
+    }
+    catch {
+        return { entries: [], problems: ['is not valid YAML'] };
+    }
+    if (!isPlainObject(doc))
+        return { entries: [], problems: ['must be a mapping with schema and namespaces'] };
+    const problems = [];
+    for (const field of Object.keys(doc))
+        if (!['schema', 'namespaces'].includes(field))
+            problems.push(`has unknown top-level field ${JSON.stringify(field)}`);
+    if (doc.schema !== LEDGER_SCHEMA)
+        problems.push(`schema must be ${LEDGER_SCHEMA}`);
+    if (!isPlainObject(doc.namespaces)) {
+        problems.push('namespaces must be a mapping of namespace to a list of entries');
+        return { entries: [], problems };
+    }
+    const entries = [];
+    for (const [namespace, list] of Object.entries(doc.namespaces)) {
+        if (!Array.isArray(list)) {
+            problems.push(`namespace ${JSON.stringify(namespace)} must be a list of entries`);
+            continue;
+        }
+        list.forEach((entry, index) => {
+            const problem = entryProblem(entry);
+            if (problem) {
+                problems.push(`namespace ${JSON.stringify(namespace)} entry ${index + 1} ${problem}`);
+                return;
+            }
+            const kind = MATCHERS.find(field => field in entry);
+            entries.push({ namespace, kind, value: entry[kind] });
+        });
+    }
+    return { entries, problems };
 }
-
 /**
  * Mark every catalog key the side's ledger names as read, and return the ledger's own findings (malformed, or an entry
  * matching no catalog key). No file means no ledger. Only a fe side reads its fe ledger and a be side its be ledger.
  */
 export function applyDynamicKeysLedger(state, profile) {
-  if (!SIDES.has(profile)) return [];
-  const source = readText(state.repoRoot, LEDGER_FILE);
-  if (source === null) return [];
-  const { entries, problems } = parseLedger(source);
-  const own = (message, name) => found(CODE, LEDGER_FILE, `${LEDGER_FILE}: ${message}`, { line: 1, column: 1, kind: 'dynamic-keys ledger', name });
-  const findings = problems.map(problem => own(`malformed dynamic-keys ledger: ${problem}.`, 'ledger'));
-  const catalog = state.candidates.filter(candidate => candidate.kind === 'catalog key').map(candidate => ({ candidate, ...splitCatalogName(candidate.name) }));
-  for (const entry of entries) {
-    const hits = catalog.filter(({ namespace, leaf }) => namespace === entry.namespace && matches(entry, leaf));
-    for (const { candidate } of hits) candidate.used = true;
-    if (!hits.length) findings.push(own(`dynamic-keys ledger entry ${describe(entry)} in namespace ${JSON.stringify(entry.namespace)} matches no catalog key; delete it.`, `${entry.namespace}:${describe(entry)}`));
-  }
-  return findings;
+    if (!SIDES.has(profile))
+        return [];
+    const source = readText(state.repoRoot, LEDGER_FILE);
+    if (source === null)
+        return [];
+    const { entries, problems } = parseLedger(source);
+    const own = (message, name) => found(CODE, LEDGER_FILE, `${LEDGER_FILE}: ${message}`, { line: 1, column: 1, kind: 'dynamic-keys ledger', name });
+    const findings = problems.map(problem => own(`malformed dynamic-keys ledger: ${problem}.`, 'ledger'));
+    const catalog = state.candidates.filter((candidate) => candidate.kind === 'catalog key').map((candidate) => ({ candidate, ...splitCatalogName(candidate.name) }));
+    for (const entry of entries) {
+        const hits = catalog.filter(({ namespace, leaf }) => namespace === entry.namespace && matches(entry, leaf));
+        for (const { candidate } of hits)
+            candidate.used = true;
+        if (!hits.length)
+            findings.push(own(`dynamic-keys ledger entry ${describe(entry)} in namespace ${JSON.stringify(entry.namespace)} matches no catalog key; delete it.`, `${entry.namespace}:${describe(entry)}`));
+    }
+    return findings;
 }

package/runtime/scripts/hfs/rules/unused-symbol-properties.d.mts

@@ -0,0 +1,12 @@
+import type { Parsed } from './rule-types.mjs';
+/** Fold writes in source order, with branch-local cycle detection and explicit absence. */
+export declare function ownerProperty(state: Parsed, owner: Parsed, name: string | null, visited: Parsed, resolve: Parsed): any;
+/** The expression bound to name in a known object literal or a JSX attribute list. */
+export declare function propertyValues(state: Parsed, owner: Parsed, name: string | null, seen: Parsed, resolve: Parsed): any;
+/** Unknown or missing owner branches cannot disappear beside a known property branch. */
+export declare function propertiesOf(state: Parsed, owners: Parsed, name: string | null, seen: Parsed, resolve: Parsed): any;
+export declare function assignmentTarget(state: Parsed, expression: Parsed, matches: Parsed): Parsed;
+/** All assignment forms share one target traversal; each consumer owns the reference it invalidates. */
+export declare function writesTarget(state: Parsed, node: Parsed, matches: Parsed): boolean;
+/** Strict-null guards narrow only an immutable reference at its actual guarded use site. */
+export declare function excludesNull(state: Parsed, node: Parsed): any;

package/runtime/scripts/hfs/rules/unused-symbol-properties.mjs

@@ -1,162 +1,177 @@
 // Ordered object and JSX property provenance for R280; unknown writers remain barriers.
 import { nameText } from '../../lib/ts-ast.mjs';
 import { unwrapCatalogExpression as unwrap } from '../../lib/ts-analysis.mjs';
-
 const ABSENT_PROPERTY = { values: [], missing: true };
-
 /** A definite write replaces earlier provenance; a missing branch keeps it, and an unknown branch is a barrier. */
 function mergeProperty(before, after) {
-  if (after === null || !after.missing) return after;
-  if (before === null) return null;
-  return { values: [...before.values, ...after.values], missing: before.missing };
+    if (after === null || !after.missing)
+        return after;
+    if (before === null)
+        return null;
+    return { values: [...before.values, ...after.values], missing: before.missing };
 }
-
 /** Every possible spread owner must be known before its property provenance is admitted. */
 function spreadProperty(state, expression, name, seen, resolve) {
-  const choices = resolve(state, expression, seen).map(owner => ownerProperty(state, owner, name, seen, resolve));
-  if (!choices.length || choices.includes(null)) return null;
-  return { values: choices.flatMap(choice => choice.values), missing: choices.some(choice => choice.missing) };
+    const choices = resolve(state, expression, seen).map((owner) => ownerProperty(state, owner, name, seen, resolve));
+    if (!choices.length || choices.includes(null))
+        return null;
+    return { values: choices.flatMap((choice) => choice.values), missing: choices.some((choice) => choice.missing) };
 }
-
 function entryProperty(state, entry, name, seen, resolve) {
-  const { ts } = state;
-  if (ts.isSpreadAssignment(entry) || ts.isJsxSpreadAttribute(entry)) return spreadProperty(state, entry.expression, name, seen, resolve);
-  const key = nameText(ts, entry.name, { numbers: true });
-  if (key === null) return null;
-  if (key !== name) return ABSENT_PROPERTY;
-  if (ts.isPropertyAssignment(entry)) return { values: [entry.initializer], missing: false };
-  if (ts.isShorthandPropertyAssignment(entry)) return { values: [entry.name], missing: false };
-  if (ts.isJsxAttribute(entry)) {
-    const value = entry.initializer && (ts.isJsxExpression(entry.initializer) ? entry.initializer.expression : entry.initializer);
-    return value ? { values: [value], missing: false } : null;
-  }
-  // A method or accessor owns the name, but does not establish a supported translator value.
-  return null;
-}
-
+    const { ts } = state;
+    if (ts.isSpreadAssignment(entry) || ts.isJsxSpreadAttribute(entry))
+        return spreadProperty(state, entry.expression, name, seen, resolve);
+    const key = nameText(ts, entry.name, { numbers: true });
+    if (key === null)
+        return null;
+    if (key !== name)
+        return ABSENT_PROPERTY;
+    if (ts.isPropertyAssignment(entry))
+        return { values: [entry.initializer], missing: false };
+    if (ts.isShorthandPropertyAssignment(entry))
+        return { values: [entry.name], missing: false };
+    if (ts.isJsxAttribute(entry)) {
+        const value = entry.initializer && (ts.isJsxExpression(entry.initializer) ? entry.initializer.expression : entry.initializer);
+        return value ? { values: [value], missing: false } : null;
+    }
+    // A method or accessor owns the name, but does not establish a supported translator value.
+    return null;
+}
 /** Fold writes in source order, with branch-local cycle detection and explicit absence. */
 export function ownerProperty(state, owner, name, visited, resolve) {
-  if ((!state.ts.isObjectLiteralExpression(owner) && !state.ts.isJsxAttributes(owner)) || visited.has(owner)) return null;
-  const seen = new Set([...visited, owner]);
-  return owner.properties.reduce((before, entry) => mergeProperty(before, entryProperty(state, entry, name, seen, resolve)), ABSENT_PROPERTY);
+    if ((!state.ts.isObjectLiteralExpression(owner) && !state.ts.isJsxAttributes(owner)) || visited.has(owner))
+        return null;
+    const seen = new Set([...visited, owner]);
+    return owner.properties.reduce((before, entry) => mergeProperty(before, entryProperty(state, entry, name, seen, resolve)), ABSENT_PROPERTY);
 }
-
 /** The expression bound to name in a known object literal or a JSX attribute list. */
 export function propertyValues(state, owner, name, seen, resolve) {
-  const property = ownerProperty(state, owner, name, seen, resolve);
-  return property && !property.missing ? property.values : [];
+    const property = ownerProperty(state, owner, name, seen, resolve);
+    return property && !property.missing ? property.values : [];
 }
-
 /** Unknown or missing owner branches cannot disappear beside a known property branch. */
 export function propertiesOf(state, owners, name, seen, resolve) {
-  const groups = owners.map(owner => propertyValues(state, owner, name, seen, resolve));
-  return groups.length && groups.every(group => group.length) ? groups.flat() : [];
+    const groups = owners.map((owner) => propertyValues(state, owner, name, seen, resolve));
+    return groups.length && groups.every((group) => group.length) ? groups.flat() : [];
 }
-
 function returnsAbruptly(ts, statement) {
-  const own = ts.isBlock(statement) && statement.statements.length === 1 ? statement.statements[0] : statement;
-  return ts.isReturnStatement(own) || ts.isThrowStatement(own);
+    const own = ts.isBlock(statement) && statement.statements.length === 1 ? statement.statements[0] : statement;
+    return ts.isReturnStatement(own) || ts.isThrowStatement(own);
 }
-
 function sameReference(state, left, right) {
-  const { ts, checker } = state;
-  const a = unwrap(ts, left), b = unwrap(ts, right);
-  if (!a || !b) return false;
-  if (ts.isIdentifier(a) && ts.isIdentifier(b)) return checker.getSymbolAtLocation(a) === checker.getSymbolAtLocation(b);
-  return ts.isPropertyAccessExpression(a) && ts.isPropertyAccessExpression(b)
-    && a.name.text === b.name.text && sameReference(state, a.expression, b.expression);
-}
-
+    const { ts, checker } = state;
+    const a = unwrap(ts, left), b = unwrap(ts, right);
+    if (!a || !b)
+        return false;
+    if (ts.isIdentifier(a) && ts.isIdentifier(b))
+        return checker.getSymbolAtLocation(a) === checker.getSymbolAtLocation(b);
+    return ts.isPropertyAccessExpression(a) && ts.isPropertyAccessExpression(b)
+        && a.name.text === b.name.text && sameReference(state, a.expression, b.expression);
+}
 function comparesNull(state, expression, reference, negative = false) {
-  const { ts } = state;
-  const node = unwrap(ts, expression);
-  const operator = negative ? ts.SyntaxKind.ExclamationEqualsEqualsToken : ts.SyntaxKind.EqualsEqualsEqualsToken;
-  if (!node || !ts.isBinaryExpression(node) || node.operatorToken.kind !== operator) return false;
-  return [[node.left, node.right], [node.right, node.left]].some(([value, nil]) =>
-    nil.kind === ts.SyntaxKind.NullKeyword && sameReference(state, value, reference));
-}
-
+    const { ts } = state;
+    const node = unwrap(ts, expression);
+    const operator = negative ? ts.SyntaxKind.ExclamationEqualsEqualsToken : ts.SyntaxKind.EqualsEqualsEqualsToken;
+    if (!node || !ts.isBinaryExpression(node) || node.operatorToken.kind !== operator)
+        return false;
+    return [[node.left, node.right], [node.right, node.left]].some(([value, nil]) => nil.kind === ts.SyntaxKind.NullKeyword && sameReference(state, value, reference));
+}
 function immutableReference(state, expression) {
-  const { ts } = state;
-  let root = unwrap(ts, expression);
-  while (root && ts.isPropertyAccessExpression(root)) root = root.expression;
-  if (!root || !ts.isIdentifier(root)) return false;
-  let declaration = state.checker.getSymbolAtLocation(root)?.valueDeclaration;
-  while (declaration && ts.isBindingElement(declaration)) declaration = declaration.parent.parent;
-  return Boolean(declaration && ts.isVariableDeclaration(declaration) && (declaration.parent.flags & ts.NodeFlags.Const));
-}
-
+    const { ts } = state;
+    let root = unwrap(ts, expression);
+    while (root && ts.isPropertyAccessExpression(root))
+        root = root.expression;
+    if (!root || !ts.isIdentifier(root))
+        return false;
+    let declaration = state.checker.getSymbolAtLocation(root)?.valueDeclaration;
+    while (declaration && ts.isBindingElement(declaration))
+        declaration = declaration.parent.parent;
+    return Boolean(declaration && ts.isVariableDeclaration(declaration) && (declaration.parent.flags & ts.NodeFlags.Const));
+}
 export function assignmentTarget(state, expression, matches) {
-  const { ts } = state;
-  const node = unwrap(ts, expression);
-  if (!node) return false;
-  if (matches(node)) return true;
-  if (ts.isArrayLiteralExpression(node)) return node.elements.some(element => assignmentTarget(state, element, matches));
-  if (ts.isObjectLiteralExpression(node)) return node.properties.some(entry => assignmentTarget(state,
-    ts.isShorthandPropertyAssignment(entry) ? entry.name : entry.initializer ?? entry.expression, matches));
-  if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) return assignmentTarget(state, node.left, matches);
-  return (ts.isSpreadElement(node) || ts.isSpreadAssignment(node)) && assignmentTarget(state, node.expression, matches);
-}
-
+    const { ts } = state;
+    const node = unwrap(ts, expression);
+    if (!node)
+        return false;
+    if (matches(node))
+        return true;
+    if (ts.isArrayLiteralExpression(node))
+        return node.elements.some((element) => assignmentTarget(state, element, matches));
+    if (ts.isObjectLiteralExpression(node))
+        return node.properties.some((entry) => assignmentTarget(state, ts.isShorthandPropertyAssignment(entry) ? entry.name : entry.initializer ?? entry.expression, matches));
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+        return assignmentTarget(state, node.left, matches);
+    return (ts.isSpreadElement(node) || ts.isSpreadAssignment(node)) && assignmentTarget(state, node.expression, matches);
+}
 /** All assignment forms share one target traversal; each consumer owns the reference it invalidates. */
 export function writesTarget(state, node, matches) {
-  const { ts } = state;
-  let written = false;
-  const visit = own => {
-    const assignment = ts.isBinaryExpression(own) && own.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && own.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
-    const unary = (ts.isPrefixUnaryExpression(own) || ts.isPostfixUnaryExpression(own)) && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(own.operator);
-    if ((assignment && assignmentTarget(state, own.left, matches)) || (unary && assignmentTarget(state, own.operand, matches))
-      || ((ts.isForOfStatement(own) || ts.isForInStatement(own)) && assignmentTarget(state, own.initializer, matches))) written = true;
-    if (!written) ts.forEachChild(own, visit);
-  };
-  if (node) visit(node);
-  return written;
-}
-
+    const { ts } = state;
+    let written = false;
+    const visit = (own) => {
+        const assignment = ts.isBinaryExpression(own) && own.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && own.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
+        const unary = (ts.isPrefixUnaryExpression(own) || ts.isPostfixUnaryExpression(own)) && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(own.operator);
+        if ((assignment && assignmentTarget(state, own.left, matches)) || (unary && assignmentTarget(state, own.operand, matches))
+            || ((ts.isForOfStatement(own) || ts.isForInStatement(own)) && assignmentTarget(state, own.initializer, matches)))
+            written = true;
+        if (!written)
+            ts.forEachChild(own, visit);
+    };
+    if (node)
+        visit(node);
+    return written;
+}
 function writesReference(state, node, reference) {
-  return writesTarget(state, node, target => {
-    for (let own = unwrap(state.ts, reference); own; own = state.ts.isPropertyAccessExpression(own) ? unwrap(state.ts, own.expression) : null) {
-      if (sameReference(state, target, own)) return true;
+    return writesTarget(state, node, (target) => {
+        for (let own = unwrap(state.ts, reference); own; own = state.ts.isPropertyAccessExpression(own) ? unwrap(state.ts, own.expression) : null) {
+            if (sameReference(state, target, own))
+                return true;
+        }
+        return false;
+    });
+}
+function priorReferenceWrite(state, node) {
+    const { ts } = state;
+    for (let child = node; child.parent; child = child.parent) {
+        const parent = child.parent;
+        if (ts.isClassLike(parent))
+            break;
+        if (ts.isFunctionLike(parent))
+            return !ts.isBlock(child) && writesReference(state, child, node);
+        if (ts.isBlock(parent) && parent.statements.slice(0, parent.statements.indexOf(child) + 1).some((statement) => writesReference(state, statement, node)))
+            return true;
     }
     return false;
-  });
 }
-
-function priorReferenceWrite(state, node) {
-  const { ts } = state;
-  for (let child = node; child.parent; child = child.parent) {
-    const parent = child.parent;
-    if (ts.isClassLike(parent)) break;
-    if (ts.isFunctionLike(parent)) return !ts.isBlock(child) && writesReference(state, child, node);
-    if (ts.isBlock(parent) && parent.statements.slice(0, parent.statements.indexOf(child) + 1).some(statement => writesReference(state, statement, node))) return true;
-  }
-  return false;
-}
-
 function conditionalExcludesNull(state, node) {
-  const { ts } = state;
-  for (let child = node; child.parent; child = child.parent) {
-    const parent = child.parent;
-    if (ts.isFunctionLike(parent) || ts.isClassLike(parent)) return false;
-    if (ts.isConditionalExpression(parent) && child !== parent.condition
-      && comparesNull(state, parent.condition, node, child === parent.whenTrue) && !writesReference(state, parent, node)) return true;
-  }
-  return false;
-}
-
+    const { ts } = state;
+    for (let child = node; child.parent; child = child.parent) {
+        const parent = child.parent;
+        if (ts.isFunctionLike(parent) || ts.isClassLike(parent))
+            return false;
+        if (ts.isConditionalExpression(parent) && child !== parent.condition
+            && comparesNull(state, parent.condition, node, child === parent.whenTrue) && !writesReference(state, parent, node))
+            return true;
+    }
+    return false;
+}
 /** Strict-null guards narrow only an immutable reference at its actual guarded use site. */
 export function excludesNull(state, node) {
-  const { ts } = state;
-  if (!immutableReference(state, node) || priorReferenceWrite(state, node)) return false;
-  if (conditionalExcludesNull(state, node)) return true;
-  if (!ts.isIdentifier(node)) return false;
-  let statement = node;
-  while (statement.parent && !ts.isBlock(statement.parent)) {
-    if (ts.isFunctionLike(statement.parent) || ts.isClassLike(statement.parent)) return false;
-    statement = statement.parent;
-  }
-  if (!statement.parent || !ts.isBlock(statement.parent)) return false;
-  const previous = statement.parent.statements.slice(0, statement.parent.statements.indexOf(statement));
-  return previous.some(guard => ts.isIfStatement(guard) && !guard.elseStatement
-    && comparesNull(state, guard.expression, node) && returnsAbruptly(ts, guard.thenStatement));
+    const { ts } = state;
+    if (!immutableReference(state, node) || priorReferenceWrite(state, node))
+        return false;
+    if (conditionalExcludesNull(state, node))
+        return true;
+    if (!ts.isIdentifier(node))
+        return false;
+    let statement = node;
+    while (statement.parent && !ts.isBlock(statement.parent)) {
+        if (ts.isFunctionLike(statement.parent) || ts.isClassLike(statement.parent))
+            return false;
+        statement = statement.parent;
+    }
+    if (!statement.parent || !ts.isBlock(statement.parent))
+        return false;
+    const previous = statement.parent.statements.slice(0, statement.parent.statements.indexOf(statement));
+    return previous.some((guard) => ts.isIfStatement(guard) && !guard.elseStatement
+        && comparesNull(state, guard.expression, node) && returnsAbruptly(ts, guard.thenStatement));
 }

package/runtime/scripts/hfs/rules/unused-symbol-translators.d.mts

@@ -0,0 +1,8 @@
+import type { Parsed } from './rule-types.mjs';
+/** Wrappers depend on translators bound in other modules, so bind until nothing new appears. */
+export declare function translationBindings(state: Parsed, sources: Parsed): void;
+/**
+ * Namespaces read by a call of `callee`; `null` stands for a translator handed in whose namespace cannot be followed
+ * (R106 reads such a key by its leaf), and no result means the call is no catalog read.
+ */
+export declare function catalogNamespace(state: Parsed, callee: Parsed): any;