@cosmicdrift/kumiko-guards 0.356.0 → 0.358.0

package/src/guard-direct-entity-writes.ts

@@ -93,7 +93,7 @@ type DirectWriteException = {
   readonly file: RegExp;
   readonly functionName: string;
   readonly table: string;
-  readonly reason: string;
+  readonly justification: string;
 };
 
 const DIRECT_WRITE_EXCEPTIONS: readonly DirectWriteException[] = [
@@ -101,7 +101,7 @@ const DIRECT_WRITE_EXCEPTIONS: readonly DirectWriteException[] = [
     file: /(^|\/)packages\/bundled-features\/src\/template-resolver\/seeding\.ts$/,
     functionName: "resolveExistingForEventStoreSeed",
     table: "templateResourcesTable",
-    reason: "Orphan projection row without events, no event-store verb possible",
+    justification: "Orphan projection row without events, no event-store verb possible",
   },
 ];
 
@@ -183,6 +183,53 @@ export function collectEsTables(files: readonly SourceFile[]): Set<TableId> {
   return tables;
 }
 
+function unwrappedIdentifierDeclId(node: Node | undefined): TableId | undefined {
+  const identifier = node && unwrapTableExpression(node).asKind(SyntaxKind.Identifier);
+  return identifier ? declIdOf(identifier) : undefined;
+}
+
+// The `{ table }` override of `r.entity(name, def, { table })`.
+function entityTableOverrideId(opts: Node | undefined): TableId | undefined {
+  if (opts?.getKind() !== SyntaxKind.ObjectLiteralExpression) return undefined;
+  const tableProp = opts.asKindOrThrow(SyntaxKind.ObjectLiteralExpression).getProperty("table");
+  if (tableProp?.getKind() !== SyntaxKind.PropertyAssignment) return undefined;
+  return unwrappedIdentifierDeclId(
+    tableProp.asKindOrThrow(SyntaxKind.PropertyAssignment).getInitializer(),
+  );
+}
+
+type EntityRegistration = {
+  readonly entityDid: TableId | undefined;
+  readonly overrideTableDid: TableId | undefined;
+};
+
+function entityRegistrationOf(call: CallExpression): EntityRegistration | undefined {
+  const expr = call.getExpression();
+  if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) return undefined;
+  if (expr.asKindOrThrow(SyntaxKind.PropertyAccessExpression).getName() !== "entity") {
+    return undefined;
+  }
+  const args = call.getArguments();
+  if (!args[0] || args[0].getKind() !== SyntaxKind.StringLiteral) return undefined;
+  return {
+    entityDid: unwrappedIdentifierDeclId(args[1]),
+    overrideTableDid: entityTableOverrideId(args[2]),
+  };
+}
+
+// `const xTable = buildEntityTable(<name>, <entityDef>)` with a rebuildable entityDef.
+function rebuildableEntityTableDeclId(
+  call: CallExpression,
+  rebuildableEntities: ReadonlySet<TableId>,
+): TableId | undefined {
+  if (call.getExpression().getText() !== "buildEntityTable") return undefined;
+  const entityDid = unwrappedIdentifierDeclId(call.getArguments()[1]);
+  if (!entityDid || !rebuildableEntities.has(entityDid)) return undefined;
+  const nameNode = call.getFirstAncestorByKind(SyntaxKind.VariableDeclaration)?.getNameNode();
+  if (nameNode?.getKind() !== SyntaxKind.Identifier) return undefined;
+  return declIdOf(nameNode.asKindOrThrow(SyntaxKind.Identifier));
+}
+
 // Tables registered via `r.entity(name, entityDef)` as a rebuildable implicit
 // projection, linked entity→table via the shared entity-def symbol (see header), not by name string.
 export function collectEntityProjectionTables(files: readonly SourceFile[]): Set<TableId> {
@@ -192,33 +239,10 @@ export function collectEntityProjectionTables(files: readonly SourceFile[]): Set
   // Pass 1: entity-def decls that r.entity makes rebuildable (+ {table} override).
   for (const sf of files) {
     for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-      const expr = call.getExpression();
-      if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) continue;
-      if (expr.asKindOrThrow(SyntaxKind.PropertyAccessExpression).getName() !== "entity") continue;
-      const args = call.getArguments();
-      if (!args[0] || args[0].getKind() !== SyntaxKind.StringLiteral) continue;
-
-      const entityIdentifier =
-        args[1] && unwrapTableExpression(args[1]).asKind(SyntaxKind.Identifier);
-      if (entityIdentifier) {
-        const did = declIdOf(entityIdentifier);
-        if (did) rebuildableEntities.add(did);
-      }
-
-      const opts = args[2];
-      if (opts?.getKind() === SyntaxKind.ObjectLiteralExpression) {
-        const tableProp = opts
-          .asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
-          .getProperty("table");
-        if (tableProp?.getKind() === SyntaxKind.PropertyAssignment) {
-          const init = tableProp.asKindOrThrow(SyntaxKind.PropertyAssignment).getInitializer();
-          const tableIdentifier = init && unwrapTableExpression(init).asKind(SyntaxKind.Identifier);
-          if (tableIdentifier) {
-            const did = declIdOf(tableIdentifier);
-            if (did) tables.add(did);
-          }
-        }
-      }
+      const registration = entityRegistrationOf(call);
+      if (!registration) continue;
+      if (registration.entityDid) rebuildableEntities.add(registration.entityDid);
+      if (registration.overrideTableDid) tables.add(registration.overrideTableDid);
     }
   }
 
@@ -226,18 +250,7 @@ export function collectEntityProjectionTables(files: readonly SourceFile[]): Set
   // is in the rebuildable set → xTable is a rebuildable entity table.
   for (const sf of files) {
     for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-      if (call.getExpression().getText() !== "buildEntityTable") continue;
-      const entityArg = call.getArguments()[1];
-      const entityIdentifier =
-        entityArg && unwrapTableExpression(entityArg).asKind(SyntaxKind.Identifier);
-      if (!entityIdentifier) continue;
-      const entityDid = declIdOf(entityIdentifier);
-      if (!entityDid || !rebuildableEntities.has(entityDid)) continue;
-
-      const varDecl = call.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
-      const nameNode = varDecl?.getNameNode();
-      if (nameNode?.getKind() !== SyntaxKind.Identifier) continue;
-      const did = declIdOf(nameNode.asKindOrThrow(SyntaxKind.Identifier));
+      const did = rebuildableEntityTableDeclId(call, rebuildableEntities);
       if (did) tables.add(did);
     }
   }
@@ -259,7 +272,7 @@ type Violation = {
    *                          projection apply (e.g. a db.transaction sub-tx
    *                          in production code).
    */
-  reason: "non-tx-receiver" | "tx-outside-apply";
+  kind: "non-tx-receiver" | "tx-outside-apply";
 };
 
 /**
@@ -427,7 +440,7 @@ export function scanDirectWrites(
         op: w.op,
         table: w.tableArg.getText(),
         snippet: call.getText().slice(0, 120),
-        reason: "tx-outside-apply",
+        kind: "tx-outside-apply",
       });
       continue;
     }
@@ -438,7 +451,7 @@ export function scanDirectWrites(
       op: w.op,
       table: w.tableArg.getText(),
       snippet: call.getText().slice(0, 120),
-      reason: "non-tx-receiver",
+      kind: "non-tx-receiver",
     });
   }
   return out;
@@ -483,7 +496,7 @@ export const guard: AstGuard = {
         violations.push({
           file: path.relative(ROOT, file),
           line: hit.line,
-          message: `[${hit.reason}] ${hit.receiver}.${hit.op}(${hit.table}) — ${hit.snippet}`,
+          message: `[${hit.kind}] ${hit.receiver}.${hit.op}(${hit.table}) — ${hit.snippet}`,
         });
       }
     }

package/src/guard-escape-hatch-declared.ts

@@ -73,11 +73,13 @@
  */
 import * as path from "node:path";
 import {
+  type BindingElement,
   type Node,
   type ObjectLiteralExpression,
   type PropertyAssignment,
   type SourceFile,
   SyntaxKind,
+  type VariableDeclaration,
   VariableDeclarationKind,
 } from "ts-morph";
 import { isFrameworkImportOf } from "./_lib/framework-import";
@@ -158,32 +160,33 @@ function isDirectTenantDbAccess(node: Node): boolean {
   return false;
 }
 
+function isTenantDbVariable(decl: VariableDeclaration): boolean {
+  if (decl.getTypeNode()?.getText() === "TenantDb") return true;
+  const init = decl.getInitializer();
+  return init !== undefined && isDirectTenantDbAccess(init);
+}
+
+function isCtxDbBindingElement(decl: BindingElement): boolean {
+  const propName = decl.getPropertyNameNode()?.getText() ?? decl.getName();
+  if (!DB_RECEIVER_NAMES.has(propName)) return false;
+  // Only `const { db } = ctx` — parameter destructuring (`({ db }) =>`)
+  // stays a deliberate false-negative, not worth the ambiguity.
+  const owner = decl.getParent()?.getParent();
+  const init = owner?.isKind(SyntaxKind.VariableDeclaration) ? owner.getInitializer() : undefined;
+  return init?.isKind(SyntaxKind.Identifier) === true && CTX_IDENTIFIER_NAMES.has(init.getText());
+}
+
+function isTenantDbDeclaration(decl: Node): boolean {
+  if (decl.isKind(SyntaxKind.VariableDeclaration)) return isTenantDbVariable(decl);
+  if (decl.isKind(SyntaxKind.BindingElement)) return isCtxDbBindingElement(decl);
+  if (decl.isKind(SyntaxKind.Parameter)) return decl.getTypeNode()?.getText() === "TenantDb";
+  return false;
+}
+
 function isTenantDbExpression(node: Node): boolean {
   if (isDirectTenantDbAccess(node)) return true;
   if (!node.isKind(SyntaxKind.Identifier)) return false;
-  const decls = node.getSymbol()?.getDeclarations() ?? [];
-  for (const decl of decls) {
-    if (decl.isKind(SyntaxKind.VariableDeclaration)) {
-      if (decl.getTypeNode()?.getText() === "TenantDb") return true;
-      const init = decl.getInitializer();
-      if (init && isDirectTenantDbAccess(init)) return true;
-    } else if (decl.isKind(SyntaxKind.BindingElement)) {
-      const propName = decl.getPropertyNameNode()?.getText() ?? decl.getName();
-      if (!DB_RECEIVER_NAMES.has(propName)) continue;
-      // Only `const { db } = ctx` — parameter destructuring (`({ db }) =>`)
-      // stays a deliberate false-negative, not worth the ambiguity.
-      const owner = decl.getParent()?.getParent();
-      const init = owner?.isKind(SyntaxKind.VariableDeclaration)
-        ? owner.getInitializer()
-        : undefined;
-      if (init?.isKind(SyntaxKind.Identifier) && CTX_IDENTIFIER_NAMES.has(init.getText())) {
-        return true;
-      }
-    } else if (decl.isKind(SyntaxKind.Parameter)) {
-      if (decl.getTypeNode()?.getText() === "TenantDb") return true;
-    }
-  }
-  return false;
+  return (node.getSymbol()?.getDeclarations() ?? []).some(isTenantDbDeclaration);
 }
 
 function findRawFindings(

package/src/guard-html-escape.ts

@@ -33,6 +33,8 @@
 import * as path from "node:path";
 import {
   type ArrowFunction,
+  type BinaryExpression,
+  type CallExpression,
   type FunctionDeclaration,
   type FunctionExpression,
   type Identifier,
@@ -215,29 +217,120 @@ function isSafeLocalCall(callee: Node, sf: SourceFile, depth: number): boolean {
   });
 }
 
-function isSafeExpression(expr: Node, sf: SourceFile, depth: number): boolean {
-  if (depth > MAX_RESOLVE_DEPTH) return false;
-  if (expr.isKind(SyntaxKind.ParenthesizedExpression)) {
-    return isSafeExpression(expr.getExpression(), sf, depth + 1);
-  }
-  if (
+function isLiteralSafeKind(expr: Node): boolean {
+  return (
     expr.isKind(SyntaxKind.StringLiteral) ||
     expr.isKind(SyntaxKind.NumericLiteral) ||
     expr.isKind(SyntaxKind.TrueKeyword) ||
-    expr.isKind(SyntaxKind.FalseKeyword)
+    expr.isKind(SyntaxKind.FalseKeyword) ||
+    expr.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)
+  );
+}
+
+// A template with an HTML tag is scanned as its own candidate (incl. its
+// html-ok comments). One without is never scanned, so its interpolations
+// must be safe here.
+function isSafeTemplateExpression(
+  expr: TemplateExpression,
+  sf: SourceFile,
+  depth: number,
+): boolean {
+  if (HTML_TAG.test(templateStaticText(expr))) return true;
+  return expr
+    .getTemplateSpans()
+    .every((span) => isSafeExpression(span.getExpression(), sf, depth + 1));
+}
+
+function isSafeBinaryExpression(expr: BinaryExpression, sf: SourceFile, depth: number): boolean {
+  const op = expr.getOperatorToken().getKind();
+  if (
+    op === SyntaxKind.QuestionQuestionToken ||
+    op === SyntaxKind.BarBarToken ||
+    op === SyntaxKind.AmpersandAmpersandToken
+  ) {
+    return (
+      isSafeExpression(expr.getLeft(), sf, depth + 1) &&
+      isSafeExpression(expr.getRight(), sf, depth + 1)
+    );
+  }
+  // String concatenation is safe when both operands are.
+  if (
+    op === SyntaxKind.PlusToken &&
+    isSafeExpression(expr.getLeft(), sf, depth + 1) &&
+    isSafeExpression(expr.getRight(), sf, depth + 1)
   ) {
     return true;
   }
-  if (expr.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) return true;
-  // A template with an HTML tag is scanned as its own candidate (incl. its
-  // html-ok comments). One without is never scanned, so its interpolations
-  // must be safe here.
-  if (expr.isKind(SyntaxKind.TemplateExpression)) {
-    if (HTML_TAG.test(templateStaticText(expr))) return true;
-    return expr
-      .getTemplateSpans()
-      .every((span) => isSafeExpression(span.getExpression(), sf, depth + 1));
+  // Arithmetic (`${width / 2}`) is safe as long as the result type is number.
+  return isCompileTimeKnownType(expr.getType());
+}
+
+function calleeName(callee: Node): string {
+  return callee.isKind(SyntaxKind.PropertyAccessExpression)
+    ? callee.getNameNode().getText()
+    : callee.getText();
+}
+
+function isSafeMapCallbackResult(
+  mapCallback: ArrowFunction | FunctionExpression,
+  sf: SourceFile,
+  depth: number,
+): boolean {
+  const body = mapCallback.getBody();
+  if (Node.isBlock(body)) {
+    const stmts = body.getStatements();
+    const only = stmts.length === 1 ? stmts[0] : undefined;
+    const ret = only && Node.isReturnStatement(only) ? only.getExpression() : undefined;
+    return ret !== undefined && isSafeExpression(ret, sf, depth + 1);
+  }
+  return isSafeExpression(body, sf, depth + 1);
+}
+
+// `.join(...)` is only safe when the joined array itself consists of
+// safe fragments (e.g. arr.map(x => escapeHtml(x)).join("")) — a raw
+// `stringArray.join("")` from foreign data (parameter/import) was
+// previously treated as unconditionally safe, a real bypass.
+function isSafeJoinOfMappedFragments(callee: Node, sf: SourceFile, depth: number): boolean {
+  if (!callee.isKind(SyntaxKind.PropertyAccessExpression)) return false;
+  const receiver = callee.getExpression();
+  if (!receiver.isKind(SyntaxKind.CallExpression)) return false;
+  if (calleeName(receiver.getExpression()) !== "map") return false;
+  const mapCallback = receiver.getArguments()[0];
+  if (
+    !mapCallback ||
+    !(
+      mapCallback.isKind(SyntaxKind.ArrowFunction) ||
+      mapCallback.isKind(SyntaxKind.FunctionExpression)
+    )
+  ) {
+    return false;
   }
+  return isSafeMapCallbackResult(mapCallback, sf, depth);
+}
+
+function isSafeCallExpression(expr: CallExpression, sf: SourceFile, depth: number): boolean {
+  const callee = expr.getExpression();
+  const name = calleeName(callee);
+  if (SAFE_CALL_NAMES.has(name)) return true;
+  if (name === "join" && isSafeJoinOfMappedFragments(callee, sf, depth)) return true;
+  if (endsWithHtmlConvention(callee)) return true;
+  if (isSafeLocalCall(callee, sf, depth)) return true;
+  return isCompileTimeKnownType(expr.getType());
+}
+
+function isSafeIdentifierExpression(ident: Identifier, sf: SourceFile, depth: number): boolean {
+  if (UPPER_SNAKE.test(ident.getText())) return true;
+  if (isSafeLocalIdentifier(ident, sf, depth)) return true;
+  return isCompileTimeKnownType(ident.getType());
+}
+
+function isSafeExpression(expr: Node, sf: SourceFile, depth: number): boolean {
+  if (depth > MAX_RESOLVE_DEPTH) return false;
+  if (expr.isKind(SyntaxKind.ParenthesizedExpression)) {
+    return isSafeExpression(expr.getExpression(), sf, depth + 1);
+  }
+  if (isLiteralSafeKind(expr)) return true;
+  if (expr.isKind(SyntaxKind.TemplateExpression)) return isSafeTemplateExpression(expr, sf, depth);
   if (expr.isKind(SyntaxKind.TaggedTemplateExpression)) return isSafeTemplateTag(expr.getTag());
   if (expr.isKind(SyntaxKind.ConditionalExpression)) {
     return (
@@ -245,77 +338,10 @@ function isSafeExpression(expr: Node, sf: SourceFile, depth: number): boolean {
       isSafeExpression(expr.getWhenFalse(), sf, depth + 1)
     );
   }
-  if (expr.isKind(SyntaxKind.BinaryExpression)) {
-    const op = expr.getOperatorToken().getKind();
-    if (
-      op === SyntaxKind.QuestionQuestionToken ||
-      op === SyntaxKind.BarBarToken ||
-      op === SyntaxKind.AmpersandAmpersandToken
-    ) {
-      return (
-        isSafeExpression(expr.getLeft(), sf, depth + 1) &&
-        isSafeExpression(expr.getRight(), sf, depth + 1)
-      );
-    }
-    // String concatenation is safe when both operands are.
-    if (
-      op === SyntaxKind.PlusToken &&
-      isSafeExpression(expr.getLeft(), sf, depth + 1) &&
-      isSafeExpression(expr.getRight(), sf, depth + 1)
-    ) {
-      return true;
-    }
-    // Arithmetic (`${width / 2}`) is safe as long as the result type is number.
-    return isCompileTimeKnownType(expr.getType());
-  }
+  if (expr.isKind(SyntaxKind.BinaryExpression)) return isSafeBinaryExpression(expr, sf, depth);
   if (endsWithHtmlConvention(expr)) return true;
-  if (expr.isKind(SyntaxKind.CallExpression)) {
-    const callee = expr.getExpression();
-    const name = callee.isKind(SyntaxKind.PropertyAccessExpression)
-      ? callee.getNameNode().getText()
-      : callee.getText();
-    if (SAFE_CALL_NAMES.has(name)) return true;
-    // `.join(...)` is only safe when the joined array itself consists of
-    // safe fragments (e.g. arr.map(x => escapeHtml(x)).join("")) — a raw
-    // `stringArray.join("")` from foreign data (parameter/import) was
-    // previously treated as unconditionally safe, a real bypass.
-    if (name === "join" && callee.isKind(SyntaxKind.PropertyAccessExpression)) {
-      const receiver = callee.getExpression();
-      if (receiver.isKind(SyntaxKind.CallExpression)) {
-        const receiverCallee = receiver.getExpression();
-        const receiverName = receiverCallee.isKind(SyntaxKind.PropertyAccessExpression)
-          ? receiverCallee.getNameNode().getText()
-          : receiverCallee.getText();
-        if (receiverName === "map") {
-          const mapCallback = receiver.getArguments()[0];
-          if (
-            mapCallback &&
-            (mapCallback.isKind(SyntaxKind.ArrowFunction) ||
-              mapCallback.isKind(SyntaxKind.FunctionExpression))
-          ) {
-            const body = mapCallback.getBody();
-            if (Node.isBlock(body)) {
-              const stmts = body.getStatements();
-              const only = stmts.length === 1 ? stmts[0] : undefined;
-              const ret = only && Node.isReturnStatement(only) ? only.getExpression() : undefined;
-              if (ret && isSafeExpression(ret, sf, depth + 1)) return true;
-            } else if (isSafeExpression(body, sf, depth + 1)) {
-              return true;
-            }
-          }
-        }
-      }
-    }
-    if (endsWithHtmlConvention(callee)) return true;
-    if (isSafeLocalCall(callee, sf, depth)) return true;
-    return isCompileTimeKnownType(expr.getType());
-  }
-  if (expr.isKind(SyntaxKind.Identifier)) {
-    const ident = expr as Identifier;
-    if (UPPER_SNAKE.test(ident.getText())) return true;
-    if (isSafeLocalIdentifier(ident, sf, depth)) return true;
-    return isCompileTimeKnownType(expr.getType());
-  }
+  if (expr.isKind(SyntaxKind.CallExpression)) return isSafeCallExpression(expr, sf, depth);
+  if (expr.isKind(SyntaxKind.Identifier)) return isSafeIdentifierExpression(expr, sf, depth);
   if (
     expr.isKind(SyntaxKind.PropertyAccessExpression) ||
     expr.isKind(SyntaxKind.ElementAccessExpression)

package/src/guard-i18n-keys.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env bun
 /**
- * Guard: i18n-Keys muessen definiert sein, bevor sie verwendet werden.
+ * Guard: i18n keys must be defined before they are used.
  *
- * Scan: t()-Calls in App-tsx, Definitionen aus r.translations und i18n-Bundles.
- * Deklarative Screen-/Nav-Keys: validateBoot (Runtime).
+ * Scan: t() calls in app tsx, definitions from r.translations and i18n bundles.
+ * Declarative screen/nav keys: validateBoot (runtime).
  *
  * Usage:
  *   bun guards/guard-i18n-keys.ts
@@ -52,8 +52,8 @@ function isI18nBundleFile(filePath: string): boolean {
     // Flat single-file bundle (src/i18n.ts), same status as src/i18n/index.ts.
     /\/i18n\.ts$/.test(filePath) ||
     /\/features\/[^/]+\/i18n\./.test(filePath) ||
-    // Deckt beliebige Tiefe unter bundled-features/src/<feature>/ ab
-    // (z.B. auch .../schema/i18n.ts), statt nur genau eine Ebene.
+    // Covers any depth below bundled-features/src/<feature>/
+    // (e.g. also .../schema/i18n.ts), not just exactly one level.
     /bundled-features\/src\/.*\/i18n\.ts$/.test(filePath)
   );
 }
@@ -240,6 +240,39 @@ function collectBundleDefinedKeys(sf: SourceFile): DefinedKey[] {
   return defined;
 }
 
+// Collects the entries of one `keys:` initializer of an inline `.translations({...})` call.
+function collectInlineKeysInitializer(
+  defined: DefinedKey[],
+  initializer: Node | undefined,
+  featureName: string,
+  file: string,
+): void {
+  if (initializer?.isKind(SyntaxKind.ObjectLiteralExpression)) {
+    for (const entry of extractKeysFromTranslationsObject(initializer)) {
+      pushDefined(defined, `${featureName}:${entry.key}`, entry.locales, file, entry.line);
+      if (entry.key.includes(":")) {
+        pushDefined(defined, entry.key, entry.locales, file, entry.line);
+      }
+    }
+  } else if (initializer?.isKind(SyntaxKind.Identifier)) {
+    // getDefinitionNodes() follows "go to definition" through an
+    // import alias to the real declaration (possibly in another
+    // file) instead of stopping at the ImportSpecifier — plain
+    // getSymbol().getDeclarations() only resolved a same-file const.
+    const decl = initializer
+      .getDefinitionNodes()
+      .find((n) => n.isKind(SyntaxKind.VariableDeclaration));
+    if (decl?.isKind(SyntaxKind.VariableDeclaration)) {
+      const bundleInit = decl.getInitializer();
+      if (bundleInit?.isKind(SyntaxKind.ObjectLiteralExpression)) {
+        for (const entry of extractKeysFromTranslationsObject(bundleInit)) {
+          addDefinedEntries(defined, [entry], file, featureName);
+        }
+      }
+    }
+  }
+}
+
 function collectInlineTranslationsDefinedKeys(sf: SourceFile): DefinedKey[] {
   const defined: DefinedKey[] = [];
   for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
@@ -255,37 +288,7 @@ function collectInlineTranslationsDefinedKeys(sf: SourceFile): DefinedKey[] {
     for (const prop of first.getProperties()) {
       if (!prop.isKind(SyntaxKind.PropertyAssignment)) continue;
       if (prop.getNameNode().getText() !== "keys") continue;
-      const initializer = prop.getInitializer();
-      if (initializer?.isKind(SyntaxKind.ObjectLiteralExpression)) {
-        for (const entry of extractKeysFromTranslationsObject(initializer)) {
-          pushDefined(
-            defined,
-            `${featureName}:${entry.key}`,
-            entry.locales,
-            relFile(sf),
-            entry.line,
-          );
-          if (entry.key.includes(":")) {
-            pushDefined(defined, entry.key, entry.locales, relFile(sf), entry.line);
-          }
-        }
-      } else if (initializer?.isKind(SyntaxKind.Identifier)) {
-        // getDefinitionNodes() follows "go to definition" through an
-        // import alias to the real declaration (possibly in another
-        // file) instead of stopping at the ImportSpecifier — plain
-        // getSymbol().getDeclarations() only resolved a same-file const.
-        const decl = initializer
-          .getDefinitionNodes()
-          .find((n) => n.isKind(SyntaxKind.VariableDeclaration));
-        if (decl?.isKind(SyntaxKind.VariableDeclaration)) {
-          const bundleInit = decl.getInitializer();
-          if (bundleInit?.isKind(SyntaxKind.ObjectLiteralExpression)) {
-            for (const entry of extractKeysFromTranslationsObject(bundleInit)) {
-              addDefinedEntries(defined, [entry], relFile(sf), featureName);
-            }
-          }
-        }
-      }
+      collectInlineKeysInitializer(defined, prop.getInitializer(), featureName, relFile(sf));
     }
   }
   return defined;