@starci/hfs 4.0.10 → 4.2.0

package/runtime/scripts/hfs/architecture/symbols.mjs

@@ -14,6 +14,7 @@
  * Specs and tests are not in the graph. The public entry of an owner is found the way dead-exports.mjs finds it.
  */
 import { canonical } from './config.mjs';
+import { hasAnyFlag } from '../../lib/ts-ast.mjs';
 import { entryOf } from './dead-exports.mjs';
 
 export const SYMBOL_RULE_IDS = ['HFS_DUPLICATE_SYMBOL', 'HFS_ALIAS_REEXPORT'];
@@ -21,41 +22,58 @@ export const SYMBOL_RULE_IDS = ['HFS_DUPLICATE_SYMBOL', 'HFS_ALIAS_REEXPORT'];
 const lineOf = (sourceFile, node) => sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
 
 /** The names a source file declares at top level and exports: Map<name, line>. Re-exports from another module declare nothing. */
+function addBindingNames(ts, sourceFile, name, into, node) {
+  if (name.kind === ts.SyntaxKind.Identifier) {
+    into.set(name.text, lineOf(sourceFile, node));
+    return;
+  }
+  for (const element of name.elements) {
+    if (element.kind === ts.SyntaxKind.BindingElement) addBindingNames(ts, sourceFile, element.name, into, node);
+  }
+}
+
+function recordStatementDeclarations(ts, sourceFile, statement, declared, exported) {
+  const kind = ts.SyntaxKind;
+  const modifiers = statement.modifiers ?? [];
+  const publish = modifiers.some(modifier => modifier.kind === kind.ExportKeyword) && !modifiers.some(modifier => modifier.kind === kind.DefaultKeyword);
+  const into = publish ? exported : declared;
+  if (statement.kind === kind.VariableStatement) {
+    for (const declaration of statement.declarationList.declarations) addBindingNames(ts, sourceFile, declaration.name, into, declaration);
+    return;
+  }
+  if (statement.name?.kind === kind.Identifier
+    && [kind.FunctionDeclaration, kind.ClassDeclaration, kind.EnumDeclaration, kind.TypeAliasDeclaration, kind.InterfaceDeclaration].includes(statement.kind)) {
+    into.set(statement.name.text, lineOf(sourceFile, statement));
+  }
+}
+
+function exposeLocalExports(localLists, declared, exported) {
+  for (const element of localLists) {
+    const local = (element.propertyName ?? element.name).text;
+    if (declared.has(local)) exported.set(element.name.text, declared.get(local));
+  }
+}
+
 function declaredExports(ts, sourceFile) {
   const kind = ts.SyntaxKind;
   const declared = new Map();
   const exported = new Map();
   const localLists = [];
-  const bindingNames = (name, into, node) => {
-    if (name.kind === kind.Identifier) into.set(name.text, lineOf(sourceFile, node));
-    else for (const element of name.elements) if (element.kind === kind.BindingElement) bindingNames(element.name, into, node);
-  };
   for (const statement of sourceFile.statements) {
     if (statement.kind === kind.ExportDeclaration) {
       if (!statement.moduleSpecifier && statement.exportClause?.kind === kind.NamedExports) localLists.push(...statement.exportClause.elements);
       continue;
     }
-    const modifiers = statement.modifiers ?? [];
-    const publish = modifiers.some(modifier => modifier.kind === kind.ExportKeyword) && !modifiers.some(modifier => modifier.kind === kind.DefaultKeyword);
-    const into = publish ? exported : declared;
-    if (statement.kind === kind.VariableStatement) {
-      for (const declaration of statement.declarationList.declarations) bindingNames(declaration.name, into, declaration);
-    } else if (statement.name?.kind === kind.Identifier
-      && [kind.FunctionDeclaration, kind.ClassDeclaration, kind.EnumDeclaration, kind.TypeAliasDeclaration, kind.InterfaceDeclaration].includes(statement.kind)) {
-      into.set(statement.name.text, lineOf(sourceFile, statement));
-    }
+    recordStatementDeclarations(ts, sourceFile, statement, declared, exported);
   }
   // `export { local }` of a name declared in this file makes that declaration exported.
-  for (const element of localLists) {
-    const local = (element.propertyName ?? element.name).text;
-    if (declared.has(local)) exported.set(element.name.text, declared.get(local));
-  }
+  exposeLocalExports(localLists, declared, exported);
   return exported;
 }
 
 /** The declaration an export of an entry resolves to: its repository-relative file and its own name, or null. */
 function declaringFile(ts, checker, graph, symbol) {
-  const resolved = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  const resolved = hasAnyFlag(symbol.flags, ts.SymbolFlags.Alias) ? checker.getAliasedSymbol(symbol) : symbol;
   for (const declaration of resolved?.declarations ?? []) {
     const rel = graph.abs(canonical(declaration.getSourceFile().fileName));
     if (rel) return { rel, name: resolved.getName() };
@@ -63,8 +81,7 @@ function declaringFile(ts, checker, graph, symbol) {
   return null;
 }
 
-function duplicateSymbols({ context, graph, config }) {
-  const { ts } = context;
+function declarationIndex(ts, graph) {
   const declarations = new Map(); // name -> Map<rel, line>
   for (const [rel, node] of graph.files) {
     for (const [name, line] of declaredExports(ts, node.sourceFile)) {
@@ -73,47 +90,72 @@ function duplicateSymbols({ context, graph, config }) {
       declarations.get(name).set(rel, line);
     }
   }
+  return declarations;
+}
+
+function duplicateViolation(scan, symbol, owner, entry) {
+  const { ts, checker, graph, declarations, seen } = scan;
+  const declaration = declaringFile(ts, checker, graph, symbol);
+  if (!declaration || declaration.name === 'default') return null;
+  const { rel: home, name } = declaration;
+  const others = [...(declarations.get(name) ?? [])].filter(([rel]) => rel !== home);
+  if (!others.length || seen.has(`${home}\0${name}`)) return null;
+  seen.add(`${home}\0${name}`);
+  const where = others.map(([rel, at]) => `${rel}:${at}`);
+  return {
+    ruleId: 'HFS_DUPLICATE_SYMBOL',
+    path: home, line: declarations.get(name).get(home) ?? 1, column: 1, name, owner: owner.root, entry,
+    otherDeclarations: where,
+    message: `${name} is exported through the public entry ${entry} (declared in ${home}) and also declared and exported in ${where.join(', ')}; one name, one declaration: rename or delete the copy.`,
+  };
+}
+
+function inspectPublicOwner(ts, context, graph, config, declarations, seen, [key, owner]) {
+  if (owner.tier === 'app') return { violations: [], surface: 0 };
+  const entry = entryOf(graph, config, key, owner);
+  if (!entry) return { violations: [], surface: 0 };
+  const entryFile = graph.files.get(entry);
+  const checker = context.checkerFor(entryFile.abs);
+  const moduleSymbol = checker?.getSymbolAtLocation(entryFile.sourceFile);
+  if (!moduleSymbol) return { violations: [], surface: 0 };
+  const violations = [];
+  const scan = { ts, checker, graph, declarations, seen };
+  let surface = 0;
+  for (const symbol of checker.getExportsOfModule(moduleSymbol)) {
+    surface += 1;
+    const violation = duplicateViolation(scan, symbol, owner, entry);
+    if (violation) violations.push(violation);
+  }
+  return { violations, surface };
+}
+
+function duplicateSymbols({ context, graph, config }) {
+  const declarations = declarationIndex(context.ts, graph);
   const violations = [];
   const seen = new Set();
   let surface = 0;
-  for (const [key, owner] of graph.ownerRoots) {
-    if (owner.tier === 'app') continue;
-    const entry = entryOf(graph, config, key, owner);
-    if (!entry) continue;
-    const entryFile = graph.files.get(entry);
-    const checker = context.checkerFor(entryFile.abs);
-    const moduleSymbol = checker?.getSymbolAtLocation(entryFile.sourceFile);
-    if (!moduleSymbol) continue;
-    for (const symbol of checker.getExportsOfModule(moduleSymbol)) {
-      surface += 1;
-      const declaration = declaringFile(ts, checker, graph, symbol);
-      if (!declaration || declaration.name === 'default') continue;
-      const { rel: home, name } = declaration;
-      const others = [...(declarations.get(name) ?? [])].filter(([rel]) => rel !== home);
-      if (!others.length || seen.has(`${home}\0${name}`)) continue;
-      seen.add(`${home}\0${name}`);
-      const where = others.map(([rel, at]) => `${rel}:${at}`);
-      violations.push({
-        ruleId: 'HFS_DUPLICATE_SYMBOL',
-        path: home, line: declarations.get(name).get(home) ?? 1, column: 1, name, owner: owner.root, entry,
-        otherDeclarations: where,
-        message: `${name} is exported through the public entry ${entry} (declared in ${home}) and also declared and exported in ${where.join(', ')}; one name, one declaration: rename or delete the copy.`,
-      });
-    }
+  for (const item of graph.ownerRoots) {
+    const result = inspectPublicOwner(context.ts, context, graph, config, declarations, seen, item);
+    violations.push(...result.violations);
+    surface += result.surface;
   }
   return { violations, surface };
 }
 
 const isExported = (ts, statement) => (statement.modifiers ?? []).some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)
   && !(statement.modifiers ?? []).some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword);
+const bareAliasExpression = (ts, expression) => ts.isIdentifier(expression)
+  || (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name) && (ts.isIdentifier(expression.expression) || ts.isPropertyAccessExpression(expression.expression)));
 
 /** The declaration `node` (an identifier, a member or a qualified name) resolves to when a repository file declares it as one of `kinds`, else null. */
 function repositoryDeclaration(ts, checker, graph, node, kinds) {
-  const target = ts.isPropertyAccessExpression(node) ? node.name : ts.isQualifiedName(node) ? node.right : node;
+  let target = node;
+  if (ts.isPropertyAccessExpression(node)) target = node.name;
+  else if (ts.isQualifiedName(node)) target = node.right;
   const symbol = checker?.getSymbolAtLocation(target);
   if (!symbol) return null;
-  const resolved = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-  const home = (resolved?.declarations ?? []).find(declaration => kinds.includes(declaration.kind) && graph.abs(canonical(declaration.getSourceFile().fileName)));
+  const resolved = hasAnyFlag(symbol.flags, ts.SymbolFlags.Alias) ? checker.getAliasedSymbol(symbol) : symbol;
+  const home = (resolved?.declarations ?? []).some(declaration => kinds.includes(declaration.kind) && graph.abs(canonical(declaration.getSourceFile().fileName)));
   return home ? resolved.getName() : null;
 }
 
@@ -122,31 +164,44 @@ function repositoryDeclaration(ts, checker, graph, node, kinds) {
  * `export const Y = X` and `export const Y = X.y` (X or y a function, class, const or enum), `export type Y = X` and
  * `export interface Y extends X {}` with no body, no type arguments and no type parameters.
  */
-function declarationAliases(ts, checker, graph, statement) {
-  const kind = ts.SyntaxKind;
-  if (!checker || !isExported(ts, statement)) return [];
-  const bare = expression => ts.isIdentifier(expression) || (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name) && (ts.isIdentifier(expression.expression) || ts.isPropertyAccessExpression(expression.expression)));
+function variableAliases(ts, checker, graph, statement, kind) {
   const found = [];
-  if (statement.kind === kind.VariableStatement) {
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer || !bare(declaration.initializer)) continue;
-      const of = repositoryDeclaration(ts, checker, graph, declaration.initializer, [kind.FunctionDeclaration, kind.ClassDeclaration, kind.VariableDeclaration, kind.EnumDeclaration]);
-      if (of && of !== declaration.name.text) found.push({ node: declaration, name: declaration.name.text, of, form: `export const ${declaration.name.text} = ${declaration.initializer.getText()}` });
-    }
-  } else if (statement.kind === kind.TypeAliasDeclaration && !statement.typeParameters?.length && ts.isTypeReferenceNode(statement.type) && !statement.type.typeArguments?.length) {
-    const of = repositoryDeclaration(ts, checker, graph, statement.type.typeName, [kind.InterfaceDeclaration, kind.TypeAliasDeclaration, kind.ClassDeclaration, kind.EnumDeclaration]);
-    if (of && of !== statement.name.text) found.push({ node: statement, name: statement.name.text, of, form: `export type ${statement.name.text} = ${statement.type.getText()}` });
-  } else if (statement.kind === kind.InterfaceDeclaration && !statement.members.length && !statement.typeParameters?.length) {
-    const heritage = (statement.heritageClauses ?? []).flatMap(clause => clause.types);
-    const [only] = heritage;
-    if (heritage.length === 1 && !only.typeArguments?.length && bare(only.expression)) {
-      const of = repositoryDeclaration(ts, checker, graph, only.expression, [kind.InterfaceDeclaration, kind.TypeAliasDeclaration, kind.ClassDeclaration]);
-      if (of && of !== statement.name.text) found.push({ node: statement, name: statement.name.text, of, form: `export interface ${statement.name.text} extends ${only.expression.getText()} {}` });
-    }
+  for (const declaration of statement.declarationList.declarations) {
+    if (!ts.isIdentifier(declaration.name) || !declaration.initializer || !bareAliasExpression(ts, declaration.initializer)) continue;
+    const of = repositoryDeclaration(ts, checker, graph, declaration.initializer, [kind.FunctionDeclaration, kind.ClassDeclaration, kind.VariableDeclaration, kind.EnumDeclaration]);
+    if (of && of !== declaration.name.text) found.push({ node: declaration, name: declaration.name.text, of, form: `export const ${declaration.name.text} = ${declaration.initializer.getText()}` });
   }
   return found;
 }
 
+function typeAliasOf(ts, checker, graph, statement, kind) {
+  if (statement.typeParameters?.length || !ts.isTypeReferenceNode(statement.type) || statement.type.typeArguments?.length) return [];
+  const of = repositoryDeclaration(ts, checker, graph, statement.type.typeName, [kind.InterfaceDeclaration, kind.TypeAliasDeclaration, kind.ClassDeclaration, kind.EnumDeclaration]);
+  return of && of !== statement.name.text
+    ? [{ node: statement, name: statement.name.text, of, form: `export type ${statement.name.text} = ${statement.type.getText()}` }]
+    : [];
+}
+
+function interfaceAliasOf(ts, checker, graph, statement, kind) {
+  if (statement.members.length || statement.typeParameters?.length) return [];
+  const heritage = (statement.heritageClauses ?? []).flatMap(clause => clause.types);
+  const [only] = heritage;
+  if (heritage.length !== 1 || only.typeArguments?.length || !bareAliasExpression(ts, only.expression)) return [];
+  const of = repositoryDeclaration(ts, checker, graph, only.expression, [kind.InterfaceDeclaration, kind.TypeAliasDeclaration, kind.ClassDeclaration]);
+  return of && of !== statement.name.text
+    ? [{ node: statement, name: statement.name.text, of, form: `export interface ${statement.name.text} extends ${only.expression.getText()} {}` }]
+    : [];
+}
+
+function declarationAliases(ts, checker, graph, statement) {
+  const kind = ts.SyntaxKind;
+  if (!checker || !isExported(ts, statement)) return [];
+  if (statement.kind === kind.VariableStatement) return variableAliases(ts, checker, graph, statement, kind);
+  if (statement.kind === kind.TypeAliasDeclaration) return typeAliasOf(ts, checker, graph, statement, kind);
+  if (statement.kind === kind.InterfaceDeclaration) return interfaceAliasOf(ts, checker, graph, statement, kind);
+  return [];
+}
+
 /** The names Next.js reads from a route segment file (layout, page, route, ...): the framework fixes them. */
 const NEXT_SEGMENT_EXPORTS = new Set([
   'generateMetadata', 'metadata', 'generateViewport', 'viewport', 'generateStaticParams', 'generateImageMetadata', 'generateSitemaps',
@@ -154,42 +209,63 @@ const NEXT_SEGMENT_EXPORTS = new Set([
 ]);
 const ROUTE_SLOT = 'fe.route';
 
+function isFrameworkName(node, name) {
+  return node.slot === ROUTE_SLOT && NEXT_SEGMENT_EXPORTS.has(name);
+}
+
+function addDeclarationAliasViolations(env, rel, node, statement, point, violations) {
+  const { ts, checker, graph } = env;
+  for (const alias of declarationAliases(ts, checker, graph, statement)) {
+    if (isFrameworkName(node, alias.name)) continue;
+    const at = point(alias.node);
+    violations.push({
+      ruleId: 'HFS_ALIAS_REEXPORT', path: rel, line: at.line + 1, column: at.character + 1, name: alias.name, aliasOf: alias.of,
+      message: `${alias.form} in ${rel} gives the declaration ${alias.of} a second name: use ${alias.of} where ${alias.name} is used and delete ${alias.name}.`,
+    });
+  }
+}
+
+function addNamespaceAliasViolation(rel, statement, clause, point, violations) {
+  const at = point(statement);
+  violations.push({
+    ruleId: 'HFS_ALIAS_REEXPORT', path: rel, line: at.line + 1, column: at.character + 1, name: clause.name.text,
+    message: `export * as ${clause.name.text} in ${rel} publishes a whole module under a second name: export the declarations it holds by their own names.`,
+  });
+}
+
+function addNamedAliasViolations(rel, node, clause, point, violations) {
+  for (const element of clause.elements) {
+    if (!element.propertyName || element.propertyName.text === element.name.text || isFrameworkName(node, element.name.text)) continue;
+    const at = point(element);
+    violations.push({
+      ruleId: 'HFS_ALIAS_REEXPORT', path: rel, line: at.line + 1, column: at.character + 1,
+      name: element.name.text, aliasOf: element.propertyName.text,
+      message: `export { ${element.propertyName.text} as ${element.name.text} } in ${rel} gives one declaration a second name: rename the declaration to ${element.name.text}, or import and export it as ${element.propertyName.text}.`,
+    });
+  }
+}
+
+function addExportAliasViolations(ts, rel, node, statement, point, violations) {
+  if (statement.kind !== ts.SyntaxKind.ExportDeclaration || !statement.exportClause) return;
+  const clause = statement.exportClause;
+  if (clause.kind === ts.SyntaxKind.NamespaceExport) {
+    addNamespaceAliasViolation(rel, statement, clause, point, violations);
+    return;
+  }
+  addNamedAliasViolations(rel, node, clause, point, violations);
+}
+
+function addStatementAliasViolations(context, graph, rel, node, statement, checker, violations) {
+  const point = target => node.sourceFile.getLineAndCharacterOfPosition(target.getStart(node.sourceFile));
+  addDeclarationAliasViolations({ ts: context.ts, checker, graph }, rel, node, statement, point, violations);
+  addExportAliasViolations(context.ts, rel, node, statement, point, violations);
+}
+
 function aliasReexports({ context, graph }) {
-  const kind = context.ts.SyntaxKind;
   const violations = [];
   for (const [rel, node] of graph.files) {
-    const frameworkName = name => node.slot === ROUTE_SLOT && NEXT_SEGMENT_EXPORTS.has(name);
-    const point = target => node.sourceFile.getLineAndCharacterOfPosition(target.getStart(node.sourceFile));
     const checker = context.checkerFor(node.abs);
-    for (const statement of node.sourceFile.statements) {
-      for (const alias of declarationAliases(context.ts, checker, graph, statement)) {
-        if (frameworkName(alias.name)) continue;
-        const at = point(alias.node);
-        violations.push({
-          ruleId: 'HFS_ALIAS_REEXPORT', path: rel, line: at.line + 1, column: at.character + 1, name: alias.name, aliasOf: alias.of,
-          message: `${alias.form} in ${rel} gives the declaration ${alias.of} a second name: use ${alias.of} where ${alias.name} is used and delete ${alias.name}.`,
-        });
-      }
-      if (statement.kind !== kind.ExportDeclaration || !statement.exportClause) continue;
-      const clause = statement.exportClause;
-      if (clause.kind === kind.NamespaceExport) {
-        const at = point(statement);
-        violations.push({
-          ruleId: 'HFS_ALIAS_REEXPORT', path: rel, line: at.line + 1, column: at.character + 1, name: clause.name.text,
-          message: `export * as ${clause.name.text} in ${rel} publishes a whole module under a second name: export the declarations it holds by their own names.`,
-        });
-        continue;
-      }
-      for (const element of clause.elements) {
-        if (!element.propertyName || element.propertyName.text === element.name.text || frameworkName(element.name.text)) continue;
-        const at = point(element);
-        violations.push({
-          ruleId: 'HFS_ALIAS_REEXPORT', path: rel, line: at.line + 1, column: at.character + 1,
-          name: element.name.text, aliasOf: element.propertyName.text,
-          message: `export { ${element.propertyName.text} as ${element.name.text} } in ${rel} gives one declaration a second name: rename the declaration to ${element.name.text}, or import and export it as ${element.propertyName.text}.`,
-        });
-      }
-    }
+    for (const statement of node.sourceFile.statements) addStatementAliasViolations(context, graph, rel, node, statement, checker, violations);
   }
   return { violations };
 }

package/runtime/scripts/hfs/architecture/test-world-files.mjs

@@ -3,7 +3,8 @@ import { allowsFile } from '../allows.mjs';
 import { locateDeclaration } from '../slots.mjs';
 import { DEFAULT_ENVIRONMENT, STACKS_DIRECTORY, STATEFUL_KINDS, namesOfService, readStack } from '../../lib/stack-services.mjs';
 import { unwrapEach } from './ast-walks.mjs';
-import { nameText, sourceLocation } from '../../lib/ts-ast.mjs';
+import { hasAnyFlag, nameText, sourceLocation } from '../../lib/ts-ast.mjs';
+import { byCodeUnit } from '../../lib/list.mjs';
 
 /**
  * R47 `test-world-files` (BE_TEST_TOPOLOGY). Judgements over the test world, read through slots, the repository's own
@@ -59,7 +60,7 @@ function defineLiteral(ts, expression) {
 function configLiteral(ts, sourceFile) {
   for (const statement of sourceFile.statements) {
     if (!ts.isVariableStatement(statement) || !isExported(ts, statement)) continue;
-    if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
+    if (!hasAnyFlag(statement.declarationList.flags, ts.NodeFlags.Const)) continue;
     for (const declaration of statement.declarationList.declarations) {
       const literal = declaration.initializer ? defineLiteral(ts, declaration.initializer) : null;
       if (literal) return literal;
@@ -73,7 +74,7 @@ function environmentOf(ts, literal) {
   const node = literal ? propertyOf(ts, literal, 'stack') : null;
   const value = node ? unwrap(ts, node) : null;
   if (!value || !ts.isStringLiteralLike(value)) return null;
-  return value.text.split(/[\\/]+/u).filter(Boolean).at(-1) ?? null;
+  return value.text.split(/[\\/]+/u).filter(Boolean).findLast(Boolean) ?? null;
 }
 
 /** The keys of the declaration's `fakes` object literal, with their positions. */
@@ -86,57 +87,63 @@ function fakeEntriesOf(ts, sourceFile, literal) {
     .filter(entry => entry.name);
 }
 
+/** The `fakedBy` entry of one `stacks` property, or null when the property does not declare one. */
+function fakedByEntry(ts, sourceFile, property) {
+  if (!ts.isPropertyAssignment(property)) return null;
+  const body = unwrap(ts, property.initializer);
+  if (!body || !ts.isObjectLiteralExpression(body)) return null;
+  const fake = propertyOf(ts, body, 'fakedBy');
+  if (!fake) return null;
+  const reason = propertyOf(ts, body, 'reason');
+  return {
+    service: nameText(ts, property.name),
+    fake: ts.isStringLiteralLike(fake) ? fake.text : '',
+    reason: reason && ts.isStringLiteralLike(reason) ? reason.text.trim() : '',
+    ...sourceLocation(sourceFile, property),
+  };
+}
+
 /** The `stacks` entries that declare `fakedBy`: [{service, fake, reason, line, column}]; a value the reader cannot read statically has an empty fake and reason. */
 function fakedByOf(ts, sourceFile, literal) {
   const node = literal ? propertyOf(ts, literal, 'stacks') : null;
   const value = node ? unwrap(ts, node) : null;
   if (!value || !ts.isObjectLiteralExpression(value)) return [];
-  const entries = [];
-  for (const property of value.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    const body = unwrap(ts, property.initializer);
-    if (!body || !ts.isObjectLiteralExpression(body)) continue;
-    const fake = propertyOf(ts, body, 'fakedBy');
-    if (!fake) continue;
-    const reason = propertyOf(ts, body, 'reason');
-    entries.push({
-      service: nameText(ts, property.name),
-      fake: ts.isStringLiteralLike(fake) ? fake.text : '',
-      reason: reason && ts.isStringLiteralLike(reason) ? reason.text.trim() : '',
-      ...sourceLocation(sourceFile, property),
-    });
-  }
-  return entries;
+  return value.properties.map(property => fakedByEntry(ts, sourceFile, property)).filter(Boolean);
 }
 
-export function checkTestWorldFiles(input) {
-  const { config, graph, ts, resolver, tree } = checkerScope(input);
-  const { suffixes } = resolver.ruleParams();
-  const violations = [];
+function registerFakeProvider(fakeProviders, relative, file) {
+  if (!relative.startsWith(FAKES_DIRECTORY)) return;
+  const [provider, ...rest] = relative.slice(FAKES_DIRECTORY.length).split('/');
+  if (rest.length > 0 && !fakeProviders.has(provider)) fakeProviders.set(provider, file);
+}
+
+function isRoleFileAtRoot(relative, suffixes) {
+  const parts = relative.slice(0, -'.ts'.length).split('.');
+  return !relative.includes('/') && parts.length >= 2 && parts.every(part => KEBAB.test(part)) && suffixes.includes(parts.at(-1));
+}
+
+function collectWorldFiles(resolver, tree, suffixes, violations) {
   const fakeProviders = new Map();
   let worldRoot = null;
   let files = 0;
-  for (const file of [...tree.files].sort()) {
+  for (const file of [...tree.files].sort(byCodeUnit)) {
     if (!file.endsWith('.ts')) continue;
     const verdict = allowsFile(resolver, file);
-    if (!verdict || verdict.slot !== WORLD_SLOT) continue;
+    if (verdict?.slot !== WORLD_SLOT) continue;
     files += 1;
     worldRoot ??= file.slice(0, file.length - verdict.relative.length);
-    if (verdict.relative.startsWith(FAKES_DIRECTORY)) {
-      const [provider, ...rest] = verdict.relative.slice(FAKES_DIRECTORY.length).split('/');
-      if (rest.length > 0 && !fakeProviders.has(provider)) fakeProviders.set(provider, file);
-    }
-    if (verdict.allowed) continue;
-    const parts = verdict.relative.slice(0, -'.ts'.length).split('.');
-    const roleFileAtRoot = !verdict.relative.includes('/') && parts.length >= 2 && parts.every(part => KEBAB.test(part)) && suffixes.includes(parts.at(-1));
-    if (roleFileAtRoot) continue;
+    registerFakeProvider(fakeProviders, verdict.relative, file);
+    if (verdict.allowed || isRoleFileAtRoot(verdict.relative, suffixes)) continue;
     violations.push({
       ruleId: RULE, path: file, line: 1, column: 1,
       message: `${file} is not allowed in the test world; src/tests/world/ holds only ${verdict.allows.join(', ')} and role-suffixed files (<name>.<role>.ts) at its root. Move it to fakes/ or kit/ (be.tests.world.kit), give it a role suffix, or delete it.`,
       slot: verdict.slot,
     });
   }
+  return { fakeProviders, worldRoot, files };
+}
 
+function worldDeclaration(config, graph, ts, worldRoot, violations) {
   const configPath = worldRoot === null ? null : `${worldRoot}${CONFIG_FILE}`;
   const configFile = configPath === null ? null : graph.files.get(configPath) ?? null;
   const literal = configFile ? configLiteral(ts, configFile.sourceFile) : null;
@@ -146,7 +153,10 @@ export function checkTestWorldFiles(input) {
       message: `${configPath} declares no world the machine can read. Declare it in the one named form \`${NAMED_FORM}\` (an exported const of a ${DEFINE} call with an object literal, imported from @starci/test-world); a default export is refused by R89 and is not read.`,
     });
   }
-  const environments = [(literal ? environmentOf(ts, literal) : null) ?? defaultEnvironment];
+  return { configPath, configFile, literal };
+}
+
+function stackServices(config, environments) {
   const services = [];
   for (const environment of environments) {
     let stack = null;
@@ -154,11 +164,15 @@ export function checkTestWorldFiles(input) {
     try { stack = readStack({ root: locateDeclaration(config.root).appRoot, environment }); } catch { stack = null; }
     for (const service of stack?.services ?? []) if (service.role !== 'service' && !services.some(known => known.name === service.name)) services.push({ ...service, environment });
   }
-  const stackHint = `${STACKS_DIRECTORY}/${environments.join(', ')}`;
-  const statefulWhy = service => (STATEFUL_KINDS.has(service.kind) ? `a ${service.kind} holds data the app reads back` : service.persistent ? 'the stack gives it a persistent volume' : null);
-  const declared = literal ? fakedByOf(ts, configFile.sourceFile, literal) : [];
-  const fakeEntries = literal ? fakeEntriesOf(ts, configFile.sourceFile, literal) : [];
+  return services;
+}
+
+function statefulWhy(service) {
+  if (STATEFUL_KINDS.has(service.kind)) return `a ${service.kind} holds data the app reads back`;
+  return service.persistent ? 'the stack gives it a persistent volume' : null;
+}
 
+function reportDeclaredFakeProblems(declared, services, fakeProviders, fakeEntries, configPath, stackHint, violations) {
   for (const entry of declared) {
     const service = services.find(candidate => candidate.name === entry.service);
     const problems = [];
@@ -173,21 +187,48 @@ export function checkTestWorldFiles(input) {
       });
     }
   }
+}
 
-  // Every fake the world runs: the repository's fakes/<provider>/ folders and the fakes entries of the declaration.
-  const fakes = [
+function worldFakes(fakeProviders, fakeEntries, configPath) {
+  return [
     ...[...fakeProviders].map(([provider, file]) => ({ name: provider, path: file, line: 1, column: 1, what: `fakes/${provider}/` })),
     ...fakeEntries.filter(entry => !fakeProviders.has(entry.name)).map(entry => ({ name: entry.name, path: configPath, line: entry.line, column: entry.column, what: `the fakes entry ${entry.name}` })),
   ].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function reportServiceFakes(fakes, services, declared, configPath, stackHint, violations) {
   for (const fake of fakes) {
     const service = services.find(candidate => namesOfService(candidate).includes(fake.name));
     if (!service) continue;
     if (declared.some(entry => entry.service === service.name && entry.fake === fake.name)) continue; // judged on its stacks entry above
     const why = statefulWhy(service);
+    let reason = `${service.name} is stateful (${why}), so no exception applies. `;
+    if (!why) {
+      const worldConfig = configPath ?? `${CONFIG_FILE} in the world`;
+      reason = `Only stateless compute that needs special hardware or an external model may be faked, and only when ${worldConfig} declares it in its stacks entry ({ fakedBy, reason }). `;
+    }
     violations.push({
       ruleId: RULE, path: fake.path, line: fake.line, column: fake.column, slot: WORLD_SLOT,
-      message: `${fake.what} fakes ${service.name} (${service.image}), which ${stackHint} declares: a service of the repository's own stack runs real in the test world. ${why ? `${service.name} is stateful (${why}), so no exception applies. ` : `Only stateless compute that needs special hardware or an external model may be faked, and only when ${configPath ?? `${CONFIG_FILE} in the world`} declares it in its stacks entry ({ fakedBy, reason }). `}Delete the fake and let the world run the real service; fakes are otherwise only for external SaaS the team does not operate.`,
+      message: `${fake.what} fakes ${service.name} (${service.image}), which ${stackHint} declares: a service of the repository's own stack runs real in the test world. ${reason}Delete the fake and let the world run the real service; fakes are otherwise only for external SaaS the team does not operate.`,
     });
   }
+}
+
+export function checkTestWorldFiles(input) {
+  const { config, graph, ts, resolver, tree } = checkerScope(input);
+  const { suffixes } = resolver.ruleParams();
+  const violations = [];
+  const { fakeProviders, worldRoot, files } = collectWorldFiles(resolver, tree, suffixes, violations);
+  const { configPath, configFile, literal } = worldDeclaration(config, graph, ts, worldRoot, violations);
+  const environments = [(literal ? environmentOf(ts, literal) : null) ?? defaultEnvironment];
+  const services = stackServices(config, environments);
+  const stackHint = `${STACKS_DIRECTORY}/${environments.join(', ')}`;
+  const declared = literal ? fakedByOf(ts, configFile.sourceFile, literal) : [];
+  const fakeEntries = literal ? fakeEntriesOf(ts, configFile.sourceFile, literal) : [];
+  reportDeclaredFakeProblems(declared, services, fakeProviders, fakeEntries, configPath, stackHint, violations);
+
+  // Every fake the world runs: the repository's fakes/<provider>/ folders and the fakes entries of the declaration.
+  const fakes = worldFakes(fakeProviders, fakeEntries, configPath);
+  reportServiceFakes(fakes, services, declared, configPath, stackHint, violations);
   return { violations, coverage: { status: 'checked', files } };
 }