@cosmicdrift/kumiko-guards 0.356.0 → 0.358.0

package/src/guard-i18n-locale-mount.ts

@@ -1,18 +1,18 @@
 #!/usr/bin/env bun
 /**
- * Guard: App-Mount-Punkte muessen das deutsche Locale-Feature registrieren,
- * wenn das Repo von @cosmicdrift/kumiko-locale-de abhaengt.
+ * Guard: app mount points must register the German locale feature
+ * when the repo depends on @cosmicdrift/kumiko-locale-de.
  *
- * guard-i18n-keys.ts prueft nur, ob ein verwendeter t()-Key definiert ist —
- * und kennt kein Konzept von "Mount-Punkt". Ein Mount, der localeDeClient()
- * (Client) bzw. localeDe() (Server) nie aufruft, faellt dort komplett durch
- * (kumiko-studio#191, publicstatus#365, infra#533).
+ * guard-i18n-keys.ts only checks whether a used t() key is defined —
+ * and has no concept of a "mount point". A mount that never calls
+ * localeDeClient() (client) or localeDe() (server) slips through there
+ * completely (kumiko-studio#191, publicstatus#365, infra#533).
  *
- * Scope-Gate: das package.json am naechsten zur Datei muss auf
- * kumiko-locale-de zeigen (aktuell kumiko-studio, publicstatus, solon,
- * offlot-app) — ein Node-Resolution-Walk ueber ts-morphs FileSystemHost statt guards/_lib/
- * roots.ts' Sibling-Repo-Liste, damit der Gate auch im In-Memory-Test der
- * Guard-Suite (kein echter Sibling-Checkout) feuert.
+ * Scope gate: the package.json closest to the file must point at
+ * kumiko-locale-de (currently kumiko-studio, publicstatus, solon,
+ * offlot-app) — a node-resolution walk over ts-morph's FileSystemHost instead
+ * of guards/_lib/roots.ts' sibling-repo list, so the gate also fires in the
+ * in-memory test of the guard suite (no real sibling checkout).
  *
  * Usage:
  *   bun guards/guard-i18n-locale-mount.ts
@@ -23,6 +23,7 @@ import {
   type FileSystemHost,
   type Identifier,
   type Node,
+  type ObjectLiteralExpression,
   type SourceFile,
   SyntaxKind,
 } from "ts-morph";
@@ -248,6 +249,39 @@ function isNothingLiteral(node: Node): boolean {
   );
 }
 
+function lookupAcrossBranches(branches: readonly Node[], depth: number): ClientFeaturesLookup {
+  const found = branches
+    .map((branch) => lookupClientFeatures(branch, depth + 1))
+    .filter((lookup) => lookup.found);
+  if (found.length === 0) return CLIENT_FEATURES_ABSENT;
+  // Which branch runs is unknown statically: German must be registered in every branch that sets clientFeatures.
+  return {
+    found: true,
+    registersGerman: found.every((lookup) => lookup.found && lookup.registersGerman),
+  };
+}
+
+function lookupInObjectLiteral(obj: ObjectLiteralExpression, depth: number): ClientFeaturesLookup {
+  for (const prop of [...obj.getProperties()].reverse()) {
+    if (
+      (prop.isKind(SyntaxKind.PropertyAssignment) ||
+        prop.isKind(SyntaxKind.ShorthandPropertyAssignment)) &&
+      prop.getNameNode().getText() === "clientFeatures"
+    ) {
+      return {
+        found: true,
+        registersGerman:
+          clientFeaturesElements(prop)?.some((el) => elementRegistersGerman(el)) ?? false,
+      };
+    }
+    if (prop.isKind(SyntaxKind.SpreadAssignment)) {
+      const spread = lookupClientFeatures(prop.getExpression(), depth + 1);
+      if (spread.found) return spread;
+    }
+  }
+  return CLIENT_FEATURES_ABSENT;
+}
+
 // Finds the clientFeatures property that wins at runtime in the mount call's
 // options — a literal right there, or an identifier pointing at a same-repo
 // constant (offlot's `APP_OPTIONS` shape). Properties are walked last to
@@ -265,37 +299,10 @@ function lookupClientFeatures(value: Node | undefined, depth = 0): ClientFeature
       : lookupClientFeatures(init, depth + 1);
   }
   const branches = conditionalBranches(unwrapped);
-  if (branches !== undefined) {
-    const found = branches
-      .map((branch) => lookupClientFeatures(branch, depth + 1))
-      .filter((lookup) => lookup.found);
-    if (found.length === 0) return CLIENT_FEATURES_ABSENT;
-    // Which branch runs is unknown statically: German must be registered in every branch that sets clientFeatures.
-    return {
-      found: true,
-      registersGerman: found.every((lookup) => lookup.found && lookup.registersGerman),
-    };
-  }
+  if (branches !== undefined) return lookupAcrossBranches(branches, depth);
   if (isNothingLiteral(unwrapped)) return CLIENT_FEATURES_ABSENT;
   if (!unwrapped.isKind(SyntaxKind.ObjectLiteralExpression)) return CLIENT_FEATURES_UNRESOLVABLE;
-  for (const prop of [...unwrapped.getProperties()].reverse()) {
-    if (
-      (prop.isKind(SyntaxKind.PropertyAssignment) ||
-        prop.isKind(SyntaxKind.ShorthandPropertyAssignment)) &&
-      prop.getNameNode().getText() === "clientFeatures"
-    ) {
-      return {
-        found: true,
-        registersGerman:
-          clientFeaturesElements(prop)?.some((el) => elementRegistersGerman(el)) ?? false,
-      };
-    }
-    if (prop.isKind(SyntaxKind.SpreadAssignment)) {
-      const spread = lookupClientFeatures(prop.getExpression(), depth + 1);
-      if (spread.found) return spread;
-    }
-  }
-  return CLIENT_FEATURES_ABSENT;
+  return lookupInObjectLiteral(unwrapped, depth);
 }
 
 function objectRegistersGermanClientFeatures(value: Node | undefined): boolean {

package/src/guard-i18n-ui-strings.ts

@@ -1,17 +1,17 @@
 #!/usr/bin/env bun
-// Kein hardcodeter UI-Text in App-Web-Code: JSX-Textknoten und Label-artige
-// String-Props müssen über t("…")-Keys laufen (guard-i18n-keys prüft dann,
-// dass die Keys definiert sind — dieser Guard schließt die Lücke davor:
-// Strings, die nie zu Keys wurden, z.B. "Lade Tenants…").
+// No hardcoded UI text in app web code: JSX text nodes and label-like
+// string props must go through t("…") keys (guard-i18n-keys then checks
+// that the keys are defined — this guard closes the gap before that:
+// strings that never became keys, e.g. "Loading tenants…").
 //
-// Teil von App-Mounting 2.0 (infra#208).
+// Part of App-Mounting 2.0 (infra#208).
 
 import { type CallExpression, type Node, type SourceFile, SyntaxKind } from "ts-morph";
 import { type AstGuard, type GuardViolation, runStandalone, type ScanSpec } from "./_lib/guard-kit";
 import { hasIgnoreTag } from "./_lib/ignore-tag";
 
-// Nur Web-/Public-Code — Server-Code (Handler-Fehlertexte) läuft über die
-// Error-i18n-Pipeline und hat eigene Guards.
+// Web/public code only — server code (handler error texts) goes through the
+// error i18n pipeline and has its own guards.
 //
 // samples/ deliberately NOT scanned (tried in infra#478, rolled back): the
 // showcase/gallery pages are dev docs about the framework API itself
@@ -38,8 +38,8 @@ const SCAN: ScanSpec = {
 const EXCLUDE = /(__tests__|\.test\.tsx?$|\.integration\.tsx?$|\.d\.ts$)/;
 const IGNORE_TAG = "kumiko-lint-ignore i18n-ui-strings";
 
-// Mindestens zwei Buchstaben in Folge = menschenlesbarer Text (lässt "—",
-// Zahlen, Interpunktion und Einzel-Zeichen durch).
+// At least two consecutive letters = human-readable text (lets "—",
+// numbers, punctuation and single characters through).
 const HUMAN_TEXT = /\p{L}{2,}/u;
 
 // i18n-Key-Shape (e.g. "tenant.nav.members", "money-horse:nav.scenarioCompare"):
@@ -147,6 +147,101 @@ function registrarCallChain(prop: Node): CallExpression[] | undefined {
   return undefined;
 }
 
+function checkJsxTextNodes(sf: SourceFile, violations: GuardViolation[]): void {
+  for (const textNode of sf.getDescendantsOfKind(SyntaxKind.JsxText)) {
+    const text = textNode.getText().trim();
+    if (!HUMAN_TEXT.test(text)) continue;
+    if (hasIgnoreTag(textNode, IGNORE_TAG)) continue;
+    violations.push({
+      file: sf.getFilePath(),
+      line: textNode.getStartLineNumber(),
+      message: `hardcoded JSX text: "${text.slice(0, 40)}${text.length > 40 ? "…" : ""}"`,
+    });
+  }
+}
+
+function checkLabelAttributes(sf: SourceFile, violations: GuardViolation[]): void {
+  for (const attr of sf.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
+    if (!LABEL_PROPS.has(attr.getNameNode().getText())) continue;
+    const init = attr.getInitializer();
+    if (init === undefined || init.getKind() !== SyntaxKind.StringLiteral) continue;
+    const value = init.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralText();
+    if (!HUMAN_TEXT.test(value)) continue;
+    if (hasIgnoreTag(attr, IGNORE_TAG)) continue;
+    violations.push({
+      file: sf.getFilePath(),
+      line: attr.getStartLineNumber(),
+      message: `hardcoded label prop ${attr.getNameNode().getText()}="${value.slice(0, 40)}"`,
+    });
+  }
+}
+
+function checkTernaryLogicalExpressions(sf: SourceFile, violations: GuardViolation[]): void {
+  // Ternary/logical JSX expressions: `{saving ? "Saving…" : "Save"}` as a
+  // child, or `title={busy ? "…" : "Send"}` on a label prop — a string
+  // literal reachable only via getDescendantsOfKind(JsxText/JsxAttribute)
+  // above never fires here since the literal sits one level deeper,
+  // inside the {…} expression.
+  for (const jsxExpr of sf.getDescendantsOfKind(SyntaxKind.JsxExpression)) {
+    const inner = jsxExpr.getExpression();
+    if (inner === undefined || !isTernaryOrLogical(inner)) continue;
+    const attr = jsxExpr.getParentIfKind(SyntaxKind.JsxAttribute);
+    if (attr !== undefined && !LABEL_PROPS.has(attr.getNameNode().getText())) continue;
+    if (hasIgnoreTag(jsxExpr, IGNORE_TAG)) continue;
+    for (const piece of collectTernaryLogicText(inner)) {
+      if (!HUMAN_TEXT.test(piece.text)) continue;
+      const shown = `${piece.text.slice(0, 40)}${piece.text.length > 40 ? "…" : ""}`;
+      violations.push({
+        file: sf.getFilePath(),
+        line: piece.node.getStartLineNumber(),
+        message:
+          attr !== undefined
+            ? `hardcoded label prop ${attr.getNameNode().getText()} in ternary/logical expression: "${shown}"`
+            : `hardcoded JSX text in ternary/logical expression: "${shown}"`,
+      });
+    }
+  }
+}
+
+function checkRegistrarLabelProperties(sf: SourceFile, violations: GuardViolation[]): void {
+  // r.nav({ label: "..." }) etc.: registrar param is conventionally
+  // named "r" across framework/bundled-features/app repos (verified,
+  // no exceptions found) — see the samples/ scan-boundary note above.
+  for (const prop of sf.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
+    if (!LABEL_PROPS.has(prop.getName())) continue;
+    if (HEADER_SPEC_PROPS.has(prop.getName())) {
+      const enclosingObject = prop.getParentIfKind(SyntaxKind.ObjectLiteralExpression);
+      const enclosingProp = enclosingObject?.getParentIfKind(SyntaxKind.PropertyAssignment);
+      if (enclosingProp?.getName() === "header") continue;
+    }
+    const init = prop.getInitializer();
+    if (init === undefined || init.getKind() !== SyntaxKind.StringLiteral) continue;
+    const value = init.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralText();
+    if (!HUMAN_TEXT.test(value) || I18N_KEY_SHAPE.test(value)) continue;
+    const callChain = registrarCallChain(prop);
+    if (callChain === undefined) continue;
+    // The agent-doc slot (kumiko-framework#2615) is LLM metadata for the
+    // AI tool catalog: English by design, never rendered as UI text. The
+    // slot is the options object handed to a call on the registrar
+    // argument chain, so forwarding it through a `defineEntity*Handler`
+    // helper is the same slot and stays exempt.
+    if (
+      prop.getName() === "description" &&
+      prop
+        .getParentIfKind(SyntaxKind.ObjectLiteralExpression)
+        ?.getParentIfKind(SyntaxKind.CallExpression) !== undefined
+    )
+      continue;
+    if (callChain.some((c) => hasIgnoreTag(c, IGNORE_TAG)) || hasIgnoreTag(prop, IGNORE_TAG))
+      continue;
+    violations.push({
+      file: sf.getFilePath(),
+      line: prop.getStartLineNumber(),
+      message: `hardcoded label property ${prop.getName()}="${value.slice(0, 40)}" in r.* call — use an i18n key instead of plain text`,
+    });
+  }
+}
+
 export const guard: AstGuard = {
   name: "i18n-UI-Strings Guard (App-Repos)",
   scan: SCAN,
@@ -157,89 +252,10 @@ export const guard: AstGuard = {
     const violations: GuardViolation[] = [];
     for (const sf of files) {
       if (EXCLUDE.test(sf.getFilePath())) continue;
-      for (const textNode of sf.getDescendantsOfKind(SyntaxKind.JsxText)) {
-        const text = textNode.getText().trim();
-        if (!HUMAN_TEXT.test(text)) continue;
-        if (hasIgnoreTag(textNode, IGNORE_TAG)) continue;
-        violations.push({
-          file: sf.getFilePath(),
-          line: textNode.getStartLineNumber(),
-          message: `hardcoded JSX text: "${text.slice(0, 40)}${text.length > 40 ? "…" : ""}"`,
-        });
-      }
-      for (const attr of sf.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
-        if (!LABEL_PROPS.has(attr.getNameNode().getText())) continue;
-        const init = attr.getInitializer();
-        if (init === undefined || init.getKind() !== SyntaxKind.StringLiteral) continue;
-        const value = init.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralText();
-        if (!HUMAN_TEXT.test(value)) continue;
-        if (hasIgnoreTag(attr, IGNORE_TAG)) continue;
-        violations.push({
-          file: sf.getFilePath(),
-          line: attr.getStartLineNumber(),
-          message: `hardcoded label prop ${attr.getNameNode().getText()}="${value.slice(0, 40)}"`,
-        });
-      }
-      // Ternary/logical JSX expressions: `{saving ? "Saving…" : "Save"}` as a
-      // child, or `title={busy ? "…" : "Send"}` on a label prop — a string
-      // literal reachable only via getDescendantsOfKind(JsxText/JsxAttribute)
-      // above never fires here since the literal sits one level deeper,
-      // inside the {…} expression.
-      for (const jsxExpr of sf.getDescendantsOfKind(SyntaxKind.JsxExpression)) {
-        const inner = jsxExpr.getExpression();
-        if (inner === undefined || !isTernaryOrLogical(inner)) continue;
-        const attr = jsxExpr.getParentIfKind(SyntaxKind.JsxAttribute);
-        if (attr !== undefined && !LABEL_PROPS.has(attr.getNameNode().getText())) continue;
-        if (hasIgnoreTag(jsxExpr, IGNORE_TAG)) continue;
-        for (const piece of collectTernaryLogicText(inner)) {
-          if (!HUMAN_TEXT.test(piece.text)) continue;
-          const shown = `${piece.text.slice(0, 40)}${piece.text.length > 40 ? "…" : ""}`;
-          violations.push({
-            file: sf.getFilePath(),
-            line: piece.node.getStartLineNumber(),
-            message:
-              attr !== undefined
-                ? `hardcoded label prop ${attr.getNameNode().getText()} in ternary/logical expression: "${shown}"`
-                : `hardcoded JSX text in ternary/logical expression: "${shown}"`,
-          });
-        }
-      }
-      // r.nav({ label: "..." }) etc.: registrar param is conventionally
-      // named "r" across framework/bundled-features/app repos (verified,
-      // no exceptions found) — see the samples/ scan-boundary note above.
-      for (const prop of sf.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
-        if (!LABEL_PROPS.has(prop.getName())) continue;
-        if (HEADER_SPEC_PROPS.has(prop.getName())) {
-          const enclosingObject = prop.getParentIfKind(SyntaxKind.ObjectLiteralExpression);
-          const enclosingProp = enclosingObject?.getParentIfKind(SyntaxKind.PropertyAssignment);
-          if (enclosingProp?.getName() === "header") continue;
-        }
-        const init = prop.getInitializer();
-        if (init === undefined || init.getKind() !== SyntaxKind.StringLiteral) continue;
-        const value = init.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralText();
-        if (!HUMAN_TEXT.test(value) || I18N_KEY_SHAPE.test(value)) continue;
-        const callChain = registrarCallChain(prop);
-        if (callChain === undefined) continue;
-        // The agent-doc slot (kumiko-framework#2615) is LLM metadata for the
-        // AI tool catalog: English by design, never rendered as UI text. The
-        // slot is the options object handed to a call on the registrar
-        // argument chain, so forwarding it through a `defineEntity*Handler`
-        // helper is the same slot and stays exempt.
-        if (
-          prop.getName() === "description" &&
-          prop
-            .getParentIfKind(SyntaxKind.ObjectLiteralExpression)
-            ?.getParentIfKind(SyntaxKind.CallExpression) !== undefined
-        )
-          continue;
-        if (callChain.some((c) => hasIgnoreTag(c, IGNORE_TAG)) || hasIgnoreTag(prop, IGNORE_TAG))
-          continue;
-        violations.push({
-          file: sf.getFilePath(),
-          line: prop.getStartLineNumber(),
-          message: `hardcoded label property ${prop.getName()}="${value.slice(0, 40)}" in r.* call — use an i18n key instead of plain text`,
-        });
-      }
+      checkJsxTextNodes(sf, violations);
+      checkLabelAttributes(sf, violations);
+      checkTernaryLogicalExpressions(sf, violations);
+      checkRegistrarLabelProperties(sf, violations);
     }
     return { violations };
   },

package/src/guard-lib-test-coverage.ts

@@ -1,30 +1,29 @@
 #!/usr/bin/env bun
-// lib/ ist die Heimat der extrahierten Logik (Berechnung, Parsing, Mapping) —
-// der no-logic-in-views-Guard schiebt sie dorthin, dieser Guard sorgt dafür,
-// dass sie an der neuen Stelle auch GETESTET ist. Für jede lib-Datei mit
-// mindestens einer exportierten Funktion muss ein Test existieren, der aus dem
-// Modul importiert, und jede exportierte Funktion muss dort namentlich
-// vorkommen.
+// lib/ is the home of extracted logic (computation, parsing, mapping) —
+// the no-logic-in-views guard pushes it there, this guard ensures it is also
+// TESTED at the new location. For every lib file with at least one exported
+// function, a test must exist that imports from the module, and every
+// exported function must appear there by name.
 //
-// Warum statisch (ts-morph) statt Coverage-Threshold: Coverage lügt zweifach —
-// sie sieht nie-importierte Module gar nicht, und "ausgeführt" heißt nicht
-// "sinnvoll geprüft" (ein Integrationstest, der die Funktion transitiv über
-// HTTP streift, färbt sie grün ohne eine einzige Assertion auf ihr Verhalten).
-// Der Guard ist der strukturelle Gegenpart: er koppelt Test↔Modul über den
-// echten Import und zählt namentliche Referenzen, nicht Zeilen. Der
-// Coverage-Threshold in bunfig.toml bleibt daneben bestehen — beide zusammen,
-// nie der Threshold allein.
+// Why static (ts-morph) instead of a coverage threshold: coverage lies twice —
+// it does not see never-imported modules at all, and "executed" does not mean
+// "meaningfully tested" (an integration test that touches the function
+// transitively over HTTP turns it green without a single assertion on its
+// behavior). This guard is the structural counterpart: it couples test↔module
+// through the real import and counts references by name, not lines. The
+// coverage threshold in bunfig.toml stays in place alongside — both together,
+// never the threshold alone.
 //
-// Ausgenommen: Dateien ohne exportierte Funktion (reine Typen/Konstanten wie
-// eine Farb-Map — ein Test dafür wäre ein Fake-Test). IO-Loader, die bereits
-// durch einen Integrationstest über HTTP gedeckt sind, tragen den ignore-Tag
-// mit wahrheitsgemäßer Begründung.
+// Excluded: files without an exported function (pure types/constants like
+// a color map — a test for those would be a fake test). IO loaders already
+// covered by an integration test over HTTP carry the ignore tag with a
+// truthful justification.
 //
-// Bewusst out-of-scope: Re-Exports (`export { foo } from "./bar"`) zählen
-// nicht als eigene Callable — die Quelldatei "./bar" trägt ihre eigene
-// Coverage-Pflicht. Kommt lib/ je re-exportierte Funktionen ohne eigene
-// Quelldatei im Scope vor, ist das ein stiller Blindspot; bisher (Stand
-// dieser Fix-Runde) kommt das Pattern in keinem App-Repo vor.
+// Deliberately out of scope: re-exports (`export { foo } from "./bar"`) do not
+// count as their own callable — the source file "./bar" carries its own
+// coverage duty. If lib/ ever contains re-exported functions without their own
+// source file in scope, that is a silent blind spot; so far (as of this fix
+// round) the pattern occurs in no app repo.
 
 import { dirname, resolve } from "node:path";
 import { Node, type SourceFile, SyntaxKind } from "ts-morph";
@@ -53,9 +52,9 @@ function isTestSupportFile(path: string): boolean {
   return /\/__tests__\//.test(path);
 }
 
-// Exportierte Callables: `export function f` und `export const f = () => …` /
-// `= function () {}`. Reine Werte (`export const X = 5`), Typen und Interfaces
-// zählen nicht — sie tragen keine Logik, die ein Verhaltenstest prüfen könnte.
+// Exported callables: `export function f` and `export const f = () => …` /
+// `= function () {}`. Pure values (`export const X = 5`), types and interfaces
+// do not count — they carry no logic a behavior test could check.
 function exportedCallables(sf: SourceFile): Export[] {
   const out: Export[] = [];
   for (const fd of sf.getFunctions()) {
@@ -76,17 +75,18 @@ function exportedCallables(sf: SourceFile): Export[] {
 }
 
 // NodeNext-Importe schreiben ".js"/".jsx", obwohl die Quelle ".ts"/".tsx" ist
-// (und analog .mjs/.cjs zu .mts/.cts) — die Extension muss beim Vergleich der
-// Modulpfade also für alle vier Paar-Varianten fallen, sonst reißt der Link.
+// (and likewise .mjs/.cjs for .mts/.cts) — the extension must therefore be
+// stripped for all four pair variants when comparing module paths, otherwise
+// the link breaks.
 function stripExt(path: string): string {
   return path.replace(/\.(?:[cm]?tsx?|[cm]?jsx?)$/, "");
 }
 
-// Ein Test ist mit einer lib-Datei verknüpft, wenn er relativ aus genau dieser
-// Datei importiert — nicht per Pfad-Konvention. Das erlaubt Tests eine Ebene
-// über lib/ (features/<x>/__tests__/foo.test.ts → "../lib/foo") und verhindert,
-// dass generische Namen (fieldText, targetForRow) in fremden Tests fälschlich
-// als Referenz zählen.
+// A test is linked to a lib file when it imports from exactly that file by
+// relative path — not by path convention. This allows tests one level above
+// lib/ (features/<x>/__tests__/foo.test.ts → "../lib/foo") and prevents
+// generic names (fieldText, targetForRow) in unrelated tests from wrongly
+// counting as a reference.
 function testImportsLib(testSf: SourceFile, libPathNoExt: string): boolean {
   const testDir = dirname(testSf.getFilePath());
   for (const imp of testSf.getImportDeclarations()) {
@@ -97,10 +97,10 @@ function testImportsLib(testSf: SourceFile, libPathNoExt: string): boolean {
   return false;
 }
 
-// Import-Deklarationen ausklammern: ein benannter Import ohne jede Nutzung
-// (`import { addFees, subFees } from "../calc"`, nur addFees aufgerufen)
-// erfuellte den Guard fuer subFees schon durch den Import-Text allein —
-// der per-Funktions-Check war fuer named imports quasi tautologisch.
+// Exclude import declarations: a named import without any usage
+// (`import { addFees, subFees } from "../calc"`, only addFees called)
+// used to satisfy the guard for subFees through the import text alone —
+// the per-function check was nearly tautological for named imports.
 function bodyTextWithoutImports(testSf: SourceFile): string {
   const importRanges = testSf
     .getDescendantsOfKind(SyntaxKind.ImportDeclaration)

package/src/guard-loadall-events.ts

@@ -1,18 +1,18 @@
 #!/usr/bin/env bun
 /**
- * Guard: blockt Aufrufe von `loadAllEventsByType()` ausserhalb von Tests,
- * Ops-Scripts und der Definition selbst.
+ * Guard: blocks calls of `loadAllEventsByType()` outside tests,
+ * ops scripts and the definition itself.
  *
- * `loadAllEventsByType` buffert ALLE Events eines aggregate_type in den
- * Speicher (ein `SELECT … ORDER BY` ohne Limit). Jenseits ~100k Events pro
- * Typ ist das ein OOM-Cliff, der erst unter Prod-Last auffällt — genau die
- * Art still-und-spät-Fehler, die ein Guard fängt bevor sie ausgeliefert wird.
+ * `loadAllEventsByType` buffers ALL events of an aggregate_type in
+ * memory (a `SELECT … ORDER BY` without a limit). Beyond ~100k events per
+ * type that is an OOM cliff that only shows under prod load — exactly the
+ * kind of silent-and-late failure a guard catches before it ships.
  *
- * Der memory-bounded Ersatz ist `streamAllEventsByType` (yield't batchweise,
- * nie mehr als batchSize Rows resident). Production-Projection-Rebuild geht
- * bereits über diesen Streaming-Pfad. `loadAllEventsByType` bleibt legitim
- * für Tests (kleine, kontrollierte Stores) und Ops-Scripts auf bekannt
- * kleinen aggregate_types — daher die Allowlist statt einer Entfernung.
+ * The memory-bounded replacement is `streamAllEventsByType` (yields in
+ * batches, never more than batchSize rows resident). Production projection
+ * rebuild already goes through this streaming path. `loadAllEventsByType` stays legitimate
+ * for tests (small, controlled stores) and ops scripts on known
+ * small aggregate_types — hence the allowlist instead of a removal.
  *
  * Usage:
  *   bun packages/guards/src/guard-loadall-events.ts
@@ -36,14 +36,14 @@ const SCAN: ScanSpec = {
   kinds: ["framework", "library"],
 };
 
-// Test-Dateien dürfen die API frei benutzen — sie sind die primären
-// Verifizierer und laufen gegen kleine, kontrollierte Stores.
+// Test files may use the API freely — they are the primary verifiers and
+// run against small, controlled stores.
 const EXCLUDE = /(__tests__|\.test\.ts$|\.integration\.ts$|\.d\.ts$)/;
 
-// Erlaubte Aufrufer: die Definition selbst + Ops-/Migration-Scripts (laufen
-// auf bekannt kleinen aggregate_types, nicht im Prod-Hot-Path).
-// ROOT ist gegen process.cwd() (Repo-Root) verankert, `^`-Anker matcht nur
-// echte Top-Level-scripts/, nicht packages/.../scripts/*.
+// Allowed callers: the definition itself + ops/migration scripts (run
+// on known small aggregate_types, not in the prod hot path).
+// ROOT is anchored to process.cwd() (repo root), the `^` anchor only matches
+// real top-level scripts/, not packages/.../scripts/*.
 const ALLOWLIST: readonly RegExp[] = [
   /^packages\/framework\/src\/event-store\/event-store\.ts$/,
   /^scripts\//,

package/src/guard-no-framed-extension-sections.ts

@@ -106,6 +106,7 @@ function addRegistryMembers(
   entries: Map<string, string>,
   visited: Set<Node>,
 ): void {
+  // skip: a registry spread into itself would otherwise recurse forever
   if (visited.has(literal)) return;
   visited.add(literal);
   for (const member of literal.getProperties()) {
@@ -140,11 +141,10 @@ function addRegistryFromExpression(
 ): void {
   if (Node.isObjectLiteralExpression(expression)) {
     addRegistryMembers(sf, expression, entries, visited);
-    return;
+  } else if (Node.isIdentifier(expression)) {
+    const init = sf.getVariableDeclaration(expression.getText())?.getInitializer();
+    if (init !== undefined) addRegistryFromExpression(sf, init, entries, visited);
   }
-  if (!Node.isIdentifier(expression)) return;
-  const init = sf.getVariableDeclaration(expression.getText())?.getInitializer();
-  if (init !== undefined) addRegistryFromExpression(sf, init, entries, visited);
 }
 
 /** Maps each registered component's identifier to the registry key usage sites reference via `__component: SOME_CONST`. */

package/src/guard-no-temporal-polyfill-import.ts

@@ -61,7 +61,7 @@ function isTypeOnlyImport(decl: ImportDeclaration): boolean {
 
 type PolyfillImport = { readonly line: number; readonly specifier: string };
 
-function findPolyfillValueImports(sf: SourceFile): PolyfillImport[] {
+function findPolyfillImportDeclarations(sf: SourceFile): PolyfillImport[] {
   const found: PolyfillImport[] = [];
   for (const decl of sf.getImportDeclarations()) {
     const specifier = decl.getModuleSpecifierValue();
@@ -69,12 +69,22 @@ function findPolyfillValueImports(sf: SourceFile): PolyfillImport[] {
       found.push({ line: decl.getStartLineNumber(), specifier });
     }
   }
+  return found;
+}
+
+function findPolyfillExportDeclarations(sf: SourceFile): PolyfillImport[] {
+  const found: PolyfillImport[] = [];
   for (const decl of sf.getExportDeclarations()) {
     const specifier = decl.getModuleSpecifierValue();
     if (specifier !== undefined && isPolyfillSpecifier(specifier) && !decl.isTypeOnly()) {
       found.push({ line: decl.getStartLineNumber(), specifier });
     }
   }
+  return found;
+}
+
+function findPolyfillRequireOrDynamicImports(sf: SourceFile): PolyfillImport[] {
+  const found: PolyfillImport[] = [];
   for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
     const callee = call.getExpression();
     const isRequireCall = Node.isIdentifier(callee) && callee.getText() === "require";
@@ -88,6 +98,14 @@ function findPolyfillValueImports(sf: SourceFile): PolyfillImport[] {
   return found;
 }
 
+function findPolyfillValueImports(sf: SourceFile): PolyfillImport[] {
+  return [
+    ...findPolyfillImportDeclarations(sf),
+    ...findPolyfillExportDeclarations(sf),
+    ...findPolyfillRequireOrDynamicImports(sf),
+  ];
+}
+
 export const guard: AstGuard = {
   name: "No-Temporal-Polyfill-Import Guard",
   scan: SCAN,