@cosmicdrift/kumiko-guards 0.331.0 → 0.333.0

package/src/guard-html-escape.ts

@@ -32,6 +32,9 @@
 
 import * as path from "node:path";
 import {
+  type ArrowFunction,
+  type FunctionDeclaration,
+  type FunctionExpression,
   type Identifier,
   Node,
   type SourceFile,
@@ -155,12 +158,60 @@ function isSafeLocalIdentifier(ident: Identifier, sf: SourceFile, depth: number)
   });
 }
 
-function calleeRootIdentifier(expr: Node): Identifier | undefined {
-  let cur = expr;
-  while (cur.isKind(SyntaxKind.PropertyAccessExpression)) {
-    cur = cur.getExpression();
+function isSafeTemplateTag(tag: Node): boolean {
+  const name = tag.isKind(SyntaxKind.PropertyAccessExpression)
+    ? tag.getNameNode().getText()
+    : tag.getText();
+  return SAFE_TEMPLATE_TAGS.has(name);
+}
+
+type LocalFunction = FunctionDeclaration | ArrowFunction | FunctionExpression;
+
+function localFunctionsOf(callee: Node, sf: SourceFile): LocalFunction[] | undefined {
+  if (!callee.isKind(SyntaxKind.Identifier)) return undefined;
+  const decls = localDeclarations(callee as Identifier, sf);
+  if (decls.length === 0) return undefined;
+  const fns: LocalFunction[] = [];
+  for (const d of decls) {
+    if (d.isKind(SyntaxKind.FunctionDeclaration)) {
+      fns.push(d);
+      continue;
+    }
+    const init = d.isKind(SyntaxKind.VariableDeclaration) ? d.getInitializer() : undefined;
+    if (init?.isKind(SyntaxKind.ArrowFunction) || init?.isKind(SyntaxKind.FunctionExpression)) {
+      fns.push(init);
+      continue;
+    }
+    return undefined;
+  }
+  return fns;
+}
+
+function returnExpressionsOf(fn: LocalFunction): Node[] | undefined {
+  const body = fn.getBody();
+  if (!body) return undefined;
+  if (!Node.isBlock(body)) return [body];
+  const out: Node[] = [];
+  for (const ret of body.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+    // Returns of nested functions belong to those, not to `fn`.
+    if (ret.getFirstAncestor((a) => Node.isFunctionLikeDeclaration(a)) !== fn) continue;
+    const expr = ret.getExpression();
+    if (expr) out.push(expr);
   }
-  return cur.isKind(SyntaxKind.Identifier) ? (cur as Identifier) : undefined;
+  return out;
+}
+
+// A call to a directly named local function is trusted only when everything
+// it returns is itself safe — `function render(x) { return x; }` is not.
+// Methods on classes/objects/namespaces (`Templates.render(...)`) are never
+// trusted by their root alone.
+function isSafeLocalCall(callee: Node, sf: SourceFile, depth: number): boolean {
+  const fns = localFunctionsOf(callee, sf);
+  if (!fns) return false;
+  return fns.every((fn) => {
+    const returns = returnExpressionsOf(fn);
+    return returns?.every((r) => isSafeExpression(r, sf, depth + 1)) === true;
+  });
 }
 
 function isSafeExpression(expr: Node, sf: SourceFile, depth: number): boolean {
@@ -176,14 +227,17 @@ function isSafeExpression(expr: Node, sf: SourceFile, depth: number): boolean {
   ) {
     return true;
   }
-  // Nested template literals are scanned as their own candidates.
-  if (
-    expr.isKind(SyntaxKind.TemplateExpression) ||
-    expr.isKind(SyntaxKind.NoSubstitutionTemplateLiteral) ||
-    expr.isKind(SyntaxKind.TaggedTemplateExpression)
-  ) {
-    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));
   }
+  if (expr.isKind(SyntaxKind.TaggedTemplateExpression)) return isSafeTemplateTag(expr.getTag());
   if (expr.isKind(SyntaxKind.ConditionalExpression)) {
     return (
       isSafeExpression(expr.getWhenTrue(), sf, depth + 1) &&
@@ -202,6 +256,14 @@ function isSafeExpression(expr: Node, sf: SourceFile, depth: number): boolean {
         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());
   }
@@ -244,8 +306,7 @@ function isSafeExpression(expr: Node, sf: SourceFile, depth: number): boolean {
       }
     }
     if (endsWithHtmlConvention(callee)) return true;
-    const root = calleeRootIdentifier(callee);
-    if (root && isSafeLocalIdentifier(root, sf, depth)) return true;
+    if (isSafeLocalCall(callee, sf, depth)) return true;
     return isCompileTimeKnownType(expr.getType());
   }
   if (expr.isKind(SyntaxKind.Identifier)) {
@@ -280,11 +341,7 @@ function isInsideErrorConstruction(tpl: Node): boolean {
 function isInsideSafeTag(tpl: Node): boolean {
   const parent = tpl.getParent();
   if (!parent?.isKind(SyntaxKind.TaggedTemplateExpression)) return false;
-  const tag = parent.getTag();
-  const name = tag.isKind(SyntaxKind.PropertyAccessExpression)
-    ? tag.getNameNode().getText()
-    : tag.getText();
-  return SAFE_TEMPLATE_TAGS.has(name);
+  return isSafeTemplateTag(parent.getTag());
 }
 
 function hasHtmlOkComment(lines: readonly string[], line: number): boolean {

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

@@ -36,14 +36,20 @@ const SCAN: ScanSpec = {
   scope: "source",
   extensions: ["ts", "tsx"],
   kinds: ["library", "app"],
-  within: ["lib/**/*.ts", "features/*/lib/**/*.ts", "**/*.test.ts", "**/*.test.tsx"],
+  within: ["lib/**/*.{ts,tsx}", "**/lib/**/*.{ts,tsx}", "**/*.test.ts", "**/*.test.tsx"],
 };
 const IGNORE_TAG = "kumiko-lint-ignore lib-test-coverage";
 
 type Export = { readonly name: string; readonly node: Node };
 
 function isTestFile(path: string): boolean {
-  return /\.test\.tsx?$/.test(path) || /\/__tests__\//.test(path);
+  return /\.test\.tsx?$/.test(path);
+}
+
+// Fixtures/helpers under __tests__/ without a .test. suffix are neither tests
+// (they must not satisfy the coverage link) nor lib sources (no test duty).
+function isTestSupportFile(path: string): boolean {
+  return /\/__tests__\//.test(path);
 }
 
 // Exportierte Callables: `export function f` und `export const f = () => …` /
@@ -126,7 +132,8 @@ export const guard: AstGuard = {
     const libFiles: SourceFile[] = [];
     for (const sf of files) {
       if (isTestFile(sf.getFilePath())) testFiles.push(sf);
-      else if (!sf.getFilePath().endsWith(".d.ts")) libFiles.push(sf);
+      else if (!sf.getFilePath().endsWith(".d.ts") && !isTestSupportFile(sf.getFilePath()))
+        libFiles.push(sf);
     }
     for (const sf of libFiles) {
       const relevant = exportedCallables(sf).filter((e) => !hasIgnoreTag(e.node, IGNORE_TAG));

package/src/guard-loadall-events.ts

@@ -20,7 +20,13 @@
 
 import * as path from "node:path";
 import { type CallExpression, type Identifier, type SourceFile, SyntaxKind } from "ts-morph";
-import { type AstGuard, type GuardViolation, runStandalone, type ScanSpec } from "./_lib/guard-kit";
+import {
+  type AstGuard,
+  type GuardViolation,
+  isLocalFinding,
+  runStandalone,
+  type ScanSpec,
+} from "./_lib/guard-kit";
 
 const ROOT = process.cwd();
 
@@ -118,7 +124,7 @@ export const guard: AstGuard = {
     const violations: GuardViolation[] = [];
     for (const sf of files) {
       if (EXCLUDE.test(sf.getFilePath())) continue;
-      for (const v of collectViolations(sf)) {
+      for (const v of collectViolations(sf).filter(isLocalFinding)) {
         violations.push({
           file: v.file,
           line: v.line,

package/src/guard-no-direct-process-env.ts

@@ -44,7 +44,8 @@ export type ProcessEnvFinding = {
 
 /** Returns true when the line contains a live process.env reference. */
 export function processEnvOnLine(line: string): boolean {
-  const code = line.replace(/\/\/.*$/, "");
+  // `(?<!:)` keeps `https://…` inside string literals from being cut as a comment.
+  const code = line.replace(/(?<!:)\/\/.*$/, "");
   return PROCESS_ENV_REF.test(code);
 }
 

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

@@ -236,7 +236,11 @@ function isDirectlyUnderSlotsHeader(obj: ObjectLiteralExpression): boolean {
   const slotsObject = headerAssignment.getFirstAncestorByKind(SyntaxKind.ObjectLiteralExpression);
   if (slotsObject === undefined) return false;
   const slotsAssignment = slotsObject.getParentIfKind(SyntaxKind.PropertyAssignment);
-  return slotsAssignment !== undefined && slotsAssignment.getName() === "slots";
+  if (slotsAssignment === undefined || slotsAssignment.getName() !== "slots") return false;
+  // Only entityEdit screens render `slots.header` as a bare header slot; other
+  // screen types (projectionDetail, entityList) use `slots` differently.
+  const screenObject = slotsAssignment.getParentIfKind(SyntaxKind.ObjectLiteralExpression);
+  return screenObject !== undefined && stringPropertyValue(screenObject, "type") === "entityEdit";
 }
 
 function mountKindFor(componentPropertyAssignment: Node): MountKind {

package/src/guard-pii-annotations.ts

@@ -175,14 +175,11 @@ function scanFieldFactories(sf: SourceFile, roots: readonly RepoRoot[]): Finding
     const line = call.getStartLineNumber();
     const file = relFile(sf, roots);
     findings.push({ file, line, fieldName, hint });
-    console.warn(
-      `  [pii-annotations WARN] ${file}:${line}  field "${fieldName}" looks like PII — mark ${hint}`,
-    );
   }
   return findings;
 }
 
-function scan(
+export function scan(
   files: readonly SourceFile[],
   roots: readonly RepoRoot[] = resolveRepoRoots(),
 ): {
@@ -243,6 +240,10 @@ function analyse(
 ): GuardOutcome {
   const { findings } = scan(files, roots);
   if (!compareBaseline) {
+    for (const f of findings)
+      console.warn(
+        `  [pii-annotations WARN] ${f.file}:${f.line}  field "${f.fieldName}" looks like PII — mark ${f.hint}`,
+      );
     console.log("  Baseline comparison skipped (--no-baseline).");
     return { violations: [] };
   }

package/src/guard-primitives-discipline.ts

@@ -92,6 +92,8 @@ export type ScopeKind = "bundled-features" | "samples" | "app";
 type ScanScope = {
   readonly kind: ScopeKind;
   readonly root: string;
+  /** Repo root the reported file labels are relative to. */
+  readonly repoRoot: string;
 };
 
 // Framework checkout enforces bundled-features + samples. App-repo checkout
@@ -103,29 +105,29 @@ type ScanScope = {
 function resolveScopes(roots: readonly RepoRoot[]): ScanScope[] {
   const frameworkRoot = roots.find((r) => r.kind === "framework");
   if (frameworkRoot) {
+    const repoRoot = frameworkRoot.absPath;
     return [
       {
         kind: "bundled-features",
-        root: path.join(frameworkRoot.absPath, "packages/bundled-features/src"),
+        root: path.join(repoRoot, "packages/bundled-features/src"),
+        repoRoot,
       },
-      { kind: "samples", root: path.join(frameworkRoot.absPath, "samples") },
+      { kind: "samples", root: path.join(repoRoot, "samples"), repoRoot },
     ];
   }
-  const appRoot = roots.find((r) => r.kind === "app" && isFlatSrcLayout(r));
-  if (appRoot) {
-    return [{ kind: "app", root: path.join(appRoot.absPath, "src") }];
+  const appRoots = roots.filter((r) => r.kind === "app" && isFlatSrcLayout(r));
+  if (appRoots.length > 0) {
+    return appRoots.map((r) => ({
+      kind: "app" as const,
+      root: path.join(r.absPath, "src"),
+      repoRoot: r.absPath,
+    }));
   }
-  const otherRoots = roots.filter((r) => r.kind !== "framework" && !isFlatSrcLayout(r));
-  return otherRoots.flatMap(sourceRootDirs).map((root) => ({ kind: "app" as const, root }));
-}
-
-function resolveRoot(roots: readonly RepoRoot[]): string {
-  const frameworkRoot = roots.find((r) => r.kind === "framework");
-  if (frameworkRoot) return frameworkRoot.absPath;
-  const appRoot = roots.find((r) => r.kind === "app" && isFlatSrcLayout(r));
-  if (appRoot) return appRoot.absPath;
-  const otherRoots = roots.filter((r) => r.kind !== "framework" && !isFlatSrcLayout(r));
-  return otherRoots[0]?.absPath ?? process.cwd();
+  return roots
+    .filter((r) => r.kind !== "framework" && !isFlatSrcLayout(r))
+    .flatMap((r) =>
+      sourceRootDirs(r).map((root) => ({ kind: "app" as const, root, repoRoot: r.absPath })),
+    );
 }
 
 type Violation = {
@@ -306,7 +308,6 @@ export const check: RepoCheck = {
       // Repo-Root aufgelöst") — the vacuity floor below reproduces that.
       return { violations: [], matchedFiles: 0, notApplicable: false };
     }
-    const root = resolveRoot(roots);
     // Pre-filter count (every file walk() found, before the web/-segment
     // filter): an app repo whose screens are schema-driven with zero
     // web/*.tsx (phronexsis before its first screen) must not be flagged as
@@ -322,7 +323,7 @@ export const check: RepoCheck = {
       const webFiles = files.filter((f) => isWebFile(f, scope.root));
       for (const file of webFiles) {
         const target = scope.kind === "samples" ? warnings : violations;
-        for (const v of checkFile(file, scope.kind, root)) {
+        for (const v of checkFile(file, scope.kind, scope.repoRoot)) {
           target.push({ file: v.file, line: v.line, message: violationMessage(v) });
         }
       }

package/src/guard-raw-interactive-elements.ts

@@ -101,17 +101,22 @@ export function baselineCounts(findings: readonly Finding[]): Record<string, num
 }
 
 const BASELINE_FILE = ".kumiko-raw-interactive-elements-baseline.json";
-const rawInteractiveElementsBaseline = baselineRatchet({
-  file: path.join(ROOT, BASELINE_FILE),
-  formatVersion: 1,
-  unit: "raw interactive HTML finding(s)",
-});
+const createBaseline = (baselineRoot: string) =>
+  baselineRatchet({
+    file: path.join(baselineRoot, BASELINE_FILE),
+    formatVersion: 1,
+    unit: "raw interactive HTML finding(s)",
+  });
 
 const REMEDIATION =
   "Framework replacement: <a> → usePrimitives().Link, <details>/<summary> → CollapsibleSection " +
   `(@cosmicdrift/kumiko-renderer-web). Genuine exception: // ${IGNORE_TAG} <reason>`;
 
-function analyse(files: readonly SourceFile[], compareBaseline: boolean): GuardOutcome {
+function analyse(
+  files: readonly SourceFile[],
+  compareBaseline: boolean,
+  baselineRoot: string,
+): GuardOutcome {
   const findings = scan(files);
   if (!compareBaseline) {
     console.log("  Baseline comparison skipped (--no-baseline).");
@@ -119,7 +124,7 @@ function analyse(files: readonly SourceFile[], compareBaseline: boolean): GuardO
   }
   const resolveLine = (file: string): number => findings.find((f) => f.file === file)?.line ?? 1;
   return {
-    violations: rawInteractiveElementsBaseline.check(baselineCounts(findings), REMEDIATION, {
+    violations: createBaseline(baselineRoot).check(baselineCounts(findings), REMEDIATION, {
       formatDriftRemediation:
         "Run `bun guards/guard-raw-interactive-elements.ts --write-baseline` once.",
       resolveLine,
@@ -127,12 +132,17 @@ function analyse(files: readonly SourceFile[], compareBaseline: boolean): GuardO
   };
 }
 
-export const guard: AstGuard = {
-  name: "Raw-Interactive-Elements Guard (App-Repos)",
-  scan: SCAN,
-  hint: REMEDIATION,
-  run: (files: readonly SourceFile[]) => analyse(files, true),
-};
+export function createGuard(options: { readonly baselineRoot?: string } = {}): AstGuard {
+  const baselineRoot = options.baselineRoot ?? ROOT;
+  return {
+    name: "Raw-Interactive-Elements Guard (App-Repos)",
+    scan: SCAN,
+    hint: REMEDIATION,
+    run: (files: readonly SourceFile[]) => analyse(files, true, baselineRoot),
+  };
+}
+
+export const guard: AstGuard = createGuard();
 
 // Flags are read ONLY here, not in run() — the shared runner
 // (run-ui-guards.ts) runs every guard with the same argv, a
@@ -142,12 +152,12 @@ if (import.meta.main) {
   if (args.includes("--write-baseline")) {
     const project = buildSharedProject([guard]);
     const findings = scan(filesForGuard(project, guard));
-    rawInteractiveElementsBaseline.write(baselineCounts(findings));
+    createBaseline(ROOT).write(baselineCounts(findings));
     process.exit(0);
   }
   if (args.includes("--no-baseline")) {
     const project = buildSharedProject([guard]);
-    analyse(filesForGuard(project, guard), false);
+    analyse(filesForGuard(project, guard), false, ROOT);
     process.exit(0);
   }
   runStandalone(guard);

package/src/guard-tailwind-scan-surface.ts

@@ -163,11 +163,12 @@ function countByFile(findings: readonly Finding[]): Record<string, number> {
 }
 
 const BASELINE_FILE = ".kumiko-tailwind-scan-surface-baseline.json";
-const tailwindScanSurfaceBaseline = baselineRatchet({
-  file: path.join(BASELINE_ROOT, BASELINE_FILE),
-  formatVersion: 1,
-  unit: "class token(s)",
-});
+const tailwindScanSurfaceBaseline = (baselineRoot: string) =>
+  baselineRatchet({
+    file: path.join(baselineRoot, BASELINE_FILE),
+    formatVersion: 1,
+    unit: "class token(s)",
+  });
 
 // Second, independent rule: a consuming app repo (studio,
 // publicstatus, …) imports Framework AND Enterprise packages by npm name
@@ -489,11 +490,12 @@ function reportPublishedScanSurfaceFindings(
 }
 
 const SOURCE_COVERAGE_BASELINE_FILE = ".kumiko-tailwind-source-coverage-baseline.json";
-const sourceCoverageBaseline = baselineRatchet({
-  file: path.join(BASELINE_ROOT, SOURCE_COVERAGE_BASELINE_FILE),
-  formatVersion: 1,
-  unit: "missing @source entry/entries",
-});
+const sourceCoverageBaseline = (baselineRoot: string) =>
+  baselineRatchet({
+    file: path.join(baselineRoot, SOURCE_COVERAGE_BASELINE_FILE),
+    formatVersion: 1,
+    unit: "missing @source entry/entries",
+  });
 
 export function sourceCoverageBaselineCounts(
   findings: readonly SourceCoverageFinding[],
@@ -503,9 +505,12 @@ export function sourceCoverageBaselineCounts(
   return counts;
 }
 
-function checkSourceCoverageBaseline(findings: readonly SourceCoverageFinding[]): GuardViolation[] {
+function checkSourceCoverageBaseline(
+  findings: readonly SourceCoverageFinding[],
+  baselineRoot: string,
+): GuardViolation[] {
   const resolveLine = (file: string): number => findings.find((f) => f.file === file)?.line ?? 1;
-  return sourceCoverageBaseline.check(
+  return sourceCoverageBaseline(baselineRoot).check(
     sourceCoverageBaselineCounts(findings),
     "Package delivers Tailwind classes without @source coverage in this app — add an @source entry for both install layouts (pattern: existing bundled-features entries).",
     {
@@ -522,9 +527,9 @@ export function baselineCounts(findings: readonly Finding[]): Record<string, num
   return countByFile(findings);
 }
 
-function checkBaseline(findings: readonly Finding[]): GuardViolation[] {
+function checkBaseline(findings: readonly Finding[], baselineRoot: string): GuardViolation[] {
   const resolveLine = (file: string): number => findings.find((f) => f.file === file)?.line ?? 1;
-  return tailwindScanSurfaceBaseline.check(
+  return tailwindScanSurfaceBaseline(baselineRoot).check(
     baselineCounts(findings),
     "Class outside the @source scan surface (renderer-web/src, renderer/src, samples/**/src) — reuse a class already emitted there, or move the styling into renderer-web.",
     {
@@ -539,6 +544,7 @@ export function analyse(
   files: readonly SourceFile[],
   compareBaseline: boolean,
   roots: readonly RepoRoot[] = resolveRepoRoots(),
+  baselineRoot: string = BASELINE_ROOT,
 ): GuardOutcome {
   const { findings } = scan(files, roots);
   const coverageFindings = scanSourceCoverage(roots);
@@ -550,23 +556,28 @@ export function analyse(
   }
   return {
     violations: [
-      ...checkBaseline(findings),
-      ...checkSourceCoverageBaseline(coverageFindings),
+      ...checkBaseline(findings, baselineRoot),
+      ...checkSourceCoverageBaseline(coverageFindings, baselineRoot),
       ...publishedScanSurfaceViolations(publishedSurfaceFindings),
     ],
   };
 }
 
-export const guard: AstGuard = {
-  name: "Tailwind-Scan-Surface Guard",
-  scan: SCAN,
-  hint:
-    "Tailwind class in bundled-features outside the @source scan surface (renderer-web/src, renderer/src, samples/**/src) " +
-    `— reuse a class already emitted there, or move the styling into renderer-web. Justified exception: // ${IGNORE_TAG} <reason>. ` +
-    "Package without @source coverage in an app: add an @source entry for both install layouts. " +
-    "@source with a node_modules/<pkg>/<segment> path: check whether <pkg> even publishes that segment (package.json files).",
-  run: (files, roots = resolveRepoRoots()) => analyse(files, true, roots),
-};
+export function createGuard(options: { readonly baselineRoot?: string } = {}): AstGuard {
+  const baselineRoot = options.baselineRoot ?? BASELINE_ROOT;
+  return {
+    name: "Tailwind-Scan-Surface Guard",
+    scan: SCAN,
+    hint:
+      "Tailwind class in bundled-features outside the @source scan surface (renderer-web/src, renderer/src, samples/**/src) " +
+      `— reuse a class already emitted there, or move the styling into renderer-web. Justified exception: // ${IGNORE_TAG} <reason>. ` +
+      "Package without @source coverage in an app: add an @source entry for both install layouts. " +
+      "@source with a node_modules/<pkg>/<segment> path: check whether <pkg> even publishes that segment (package.json files).",
+    run: (files, roots = resolveRepoRoots()) => analyse(files, true, roots, baselineRoot),
+  };
+}
+
+export const guard: AstGuard = createGuard();
 
 // Flags are read ONLY here, not in run() — the shared runner
 // (run-ui-guards.ts) runs every guard with the same argv, a
@@ -576,8 +587,8 @@ if (import.meta.main) {
   if (args.includes("--write-baseline")) {
     const project = buildSharedProject([guard]);
     const { findings } = scan(filesForGuard(project, guard), resolveRepoRoots());
-    tailwindScanSurfaceBaseline.write(baselineCounts(findings));
-    sourceCoverageBaseline.write(
+    tailwindScanSurfaceBaseline(BASELINE_ROOT).write(baselineCounts(findings));
+    sourceCoverageBaseline(BASELINE_ROOT).write(
       sourceCoverageBaselineCounts(scanSourceCoverage(resolveRepoRoots())),
     );
     process.exit(0);

package/src/guard-tenant-escalation.ts

@@ -47,17 +47,16 @@ import * as path from "node:path";
 import { type Node, type SourceFile, SyntaxKind } from "ts-morph";
 import { type AstGuard, runStandalone, type ScanSpec } from "./_lib/guard-kit";
 import { literalStringOf, mentionsAsWord, nameForms } from "./_lib/handler-name-forms";
+import { TEST_FILE_RE } from "./_lib/test-file";
 
 const ROOT = process.cwd();
 
 const SCAN: ScanSpec = {
-  scope: "source",
+  scope: "source+tests",
   extensions: ["ts"],
   frameworkWithin: ["packages/*/src/**", "samples/**"],
 };
 
-const TEST_FILE = /\.test\.ts$/;
-
 // Quoted forms — a test "rejects this role" assertion carries the literal.
 const RESERVED_ROLE_LITERALS = ['"SystemAdmin"', '"system"', '"all"', '"anonymous"'];
 
@@ -81,7 +80,7 @@ function resolvedSchemaText(schemaProp: Node): string {
 export function findRoleInputHandlers(files: readonly SourceFile[]): RoleHandler[] {
   const out: RoleHandler[] = [];
   for (const sf of files) {
-    if (TEST_FILE.test(sf.getFilePath())) continue;
+    if (TEST_FILE_RE.test(sf.getFilePath())) continue;
     for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
       if (call.getExpression().getText() !== "defineWriteHandler") continue;
       const arg = call.getArguments()[0];
@@ -105,7 +104,7 @@ export function findRoleInputHandlers(files: readonly SourceFile[]): RoleHandler
 function reservedRoleTestTexts(files: readonly SourceFile[]): string[] {
   const out: string[] = [];
   for (const sf of files) {
-    if (!TEST_FILE.test(sf.getFilePath())) continue;
+    if (!TEST_FILE_RE.test(sf.getFilePath())) continue;
     const text = sf.getFullText();
     if (RESERVED_ROLE_LITERALS.some((r) => text.includes(r))) out.push(text);
   }
@@ -133,7 +132,7 @@ type OverrideHandler = { file: string; line: number };
 export function findOverrideHandlersMissingHelper(files: readonly SourceFile[]): OverrideHandler[] {
   const out: OverrideHandler[] = [];
   for (const sf of files) {
-    if (TEST_FILE.test(sf.getFilePath())) continue;
+    if (TEST_FILE_RE.test(sf.getFilePath())) continue;
     for (const pa of sf.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
       if (pa.getName() !== "tenantIdOverride") continue;
       if (pa.getInitializer()?.getText().startsWith("z.") !== true) continue;
@@ -181,7 +180,7 @@ function lineOfMatch(text: string, re: RegExp): number {
 export function findMembershipMintsMissingStrip(files: readonly SourceFile[]): MintSite[] {
   const out: MintSite[] = [];
   for (const sf of files) {
-    if (TEST_FILE.test(sf.getFilePath())) continue;
+    if (TEST_FILE_RE.test(sf.getFilePath())) continue;
     const text = sf.getFullText();
     if (!SESSION_MINT.test(text)) continue;
     if (!MEMBERSHIP_SOURCE.test(text)) continue;
@@ -223,7 +222,7 @@ export function findGlobalUserWritesMissingMembershipCheck(
 ): GlobalUserWrite[] {
   const out: GlobalUserWrite[] = [];
   for (const sf of files) {
-    if (TEST_FILE.test(sf.getFilePath())) continue;
+    if (TEST_FILE_RE.test(sf.getFilePath())) continue;
     for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
       if (call.getExpression().getText() !== "defineWriteHandler") continue;
       const arg = call.getArguments()[0];

package/src/guard-test-stack-drift.ts

@@ -17,7 +17,7 @@
  */
 
 import * as path from "node:path";
-import { Project, type SourceFile, SyntaxKind } from "ts-morph";
+import { type Identifier, Node, Project, type SourceFile, SyntaxKind } from "ts-morph";
 import {
   type GuardViolation,
   type RepoCheck,
@@ -70,10 +70,23 @@ export interface Violation {
   forbiddenCalls: Array<{ name: string; line: number }>;
 }
 
+// `import { setupTestStack as stack }` + `stack()` must resolve to the imported
+// name, otherwise an alias hides both entrypoints and forbidden factories.
+function importedNameOf(identifier: Identifier): string {
+  const localName = identifier.getText();
+  for (const imp of identifier.getSourceFile().getImportDeclarations()) {
+    for (const spec of imp.getNamedImports()) {
+      if ((spec.getAliasNode()?.getText() ?? spec.getName()) === localName) return spec.getName();
+    }
+  }
+  return localName;
+}
+
 function collectCallNames(sf: SourceFile): Map<string, number[]> {
   const calls = new Map<string, number[]>();
   for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-    const name = call.getExpression().getText();
+    const callee = call.getExpression();
+    const name = Node.isIdentifier(callee) ? importedNameOf(callee) : callee.getText();
     const arr = calls.get(name) ?? [];
     arr.push(call.getStartLineNumber());
     calls.set(name, arr);

package/src/guard-text-field-stance.ts

@@ -144,9 +144,6 @@ function scanFieldFactories(sf: SourceFile, roots: readonly RepoRoot[]): Finding
     const place = enclosingFieldName(call) ?? `${callee}(...)`;
     const line = call.getStartLineNumber();
     findings.push({ file, line, place, callee });
-    console.warn(
-      `  [text-field-stance WARN] ${file}:${line}  ${callee}(...) at "${place}" has no personal stance — mark ${VALID_PERSONAL_HINT}`,
-    );
   }
   return findings;
 }
@@ -212,6 +209,10 @@ function analyse(
 ): GuardOutcome {
   const { findings } = scan(files, roots);
   if (!compareBaseline) {
+    for (const f of findings)
+      console.warn(
+        `  [text-field-stance WARN] ${f.file}:${f.line}  ${f.callee}(...) at "${f.place}" has no personal stance — mark ${VALID_PERSONAL_HINT}`,
+      );
     console.log("  Baseline comparison skipped (--no-baseline).");
     return { violations: [] };
   }

package/src/guard-thin-wrappers.ts

@@ -67,6 +67,8 @@ function isKnownReason(r: string): r is WrapperReason {
 // ── Built-in filter ─────────────────────────────────────────────────────
 
 const BUILTIN_NAMES = new Set([
+  "test",
+  "exec",
   "push",
   "pop",
   "shift",
@@ -300,9 +302,6 @@ function extractCalleeName(callNode: ReturnType<FnNode["getBody"]> | undefined):
   if (!expr) return null;
   if (expr.isKind(SyntaxKind.Identifier)) return expr.getText();
   if (expr.isKind(SyntaxKind.PropertyAccessExpression)) {
-    // `/re/.test(x)` is a RegExp method call, not a call to a function named
-    // "test" — a regex-literal receiver is never a wrapper callee.
-    if (expr.getExpression().isKind(SyntaxKind.RegularExpressionLiteral)) return null;
     return expr.getName();
   }
   return null;