@starci/eslint-canon-fe 8.2.18 → 8.4.0

package/runtime/scripts/hfs/architecture/function-spec-providers.mjs

@@ -0,0 +1,153 @@
+import path from 'node:path';
+
+export const keyOf = (ts, property) => (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) && (ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) ? property.name.text : null;
+const exported = (ts, statement) => statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+
+/** The directly defined functions among the declarations of an exported variable statement; other values are not callable. */
+function callableVariables(ts, statement) {
+  const names = [];
+  for (const declaration of statement.declarationList.declarations) {
+    const initializer = declaration.initializer;
+    if (ts.isIdentifier(declaration.name) && initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer))) names.push(declaration.name.text);
+  }
+  return names;
+}
+
+/** The callable exports of one statement: an overload signature has no body and collapses into its implementation. */
+function callableExports(ts, statement) {
+  if (!exported(ts, statement)) return [];
+  if (ts.isFunctionDeclaration(statement)) return statement.name && statement.body ? [statement.name.text] : [];
+  return ts.isVariableStatement(statement) ? callableVariables(ts, statement) : [];
+}
+
+/**
+ * The callable subset of a function subject's exports. Constants, enums, objects, types, `export ... from` re-exports and overload
+ * signatures do not change which functions the spec must provide; a class or a default-export assignment keeps the class-provider
+ * check (null), as does a module with no callable export.
+ */
+export function functionSubjectExports(ts, sourceFile) {
+  const names = [];
+  for (const statement of sourceFile.statements) {
+    if (ts.isClassDeclaration(statement) || ts.isExportAssignment(statement)) return null;
+    for (const name of callableExports(ts, statement)) if (!names.includes(name)) names.push(name);
+  }
+  return names.length ? names : null;
+}
+
+const decoratorsOf = (ts, node) => (ts.canHaveDecorators(node) ? ts.getDecorators(node) ?? [] : []);
+
+/** A value object: an undecorated class whose constructor parameters carry no injection token, so Nest never builds it. */
+function isValueObjectClass(ts, declaration) {
+  if (decoratorsOf(ts, declaration).length > 0) return false;
+  const constructors = declaration.members.filter(member => ts.isConstructorDeclaration(member));
+  return constructors.every(constructor => constructor.parameters.every(parameter => decoratorsOf(ts, parameter).length === 0));
+}
+
+/** The names of the value-object classes a module exports, or null when it exports a class that is not one (or none). */
+export function valueObjectSubjects(ts, sourceFile) {
+  const classes = sourceFile.statements.filter(statement => ts.isClassDeclaration(statement) && statement.name && exported(ts, statement));
+  if (!classes.length || !classes.every(declaration => isValueObjectClass(ts, declaration))) return null;
+  return classes.map(declaration => declaration.name.text);
+}
+
+/** The value of one literal object property. */
+const propertyValue = (ts, object, key) => {
+  const property = object.properties.find(item => keyOf(ts, item) === key);
+  return property && ts.isPropertyAssignment(property) ? property.initializer : null;
+};
+
+/** A literal value object maps every exported function to its real sibling import. */
+function realFunctions(ts, value, names, imports, rel, serviceRel) {
+  if (!value || !ts.isObjectLiteralExpression(value) || value.properties.length !== names.length) return false;
+  const remaining = new Set(names);
+  for (const property of value.properties) {
+    const key = keyOf(ts, property);
+    const identifier = ts.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+    if (!remaining.delete(key) || !identifier || !ts.isIdentifier(identifier)) return false;
+    const binding = imports.get(identifier.text);
+    if (!binding || binding.name !== key || !binding.module.startsWith('.')) return false;
+    const target = path.posix.normalize(path.posix.join(path.posix.dirname(rel), binding.module)).replace(/\.[cm]?[jt]s$/u, '');
+    if (target !== serviceRel.replace(/\.ts$/u, '')) return false;
+  }
+  return remaining.size === 0;
+}
+
+/** Every node satisfying a predicate, within one spec. */
+function matchingNodes(ts, root, predicate) {
+  const found = [];
+  const visit = node => {
+    if (predicate(node)) found.push(node);
+    ts.forEachChild(node, visit);
+  };
+  visit(root);
+  return found;
+}
+
+/** The declared variable initialized by an expression, including its await and call chain. */
+function initializedVariable(ts, expression) {
+  let cursor = expression;
+  let compiled = false;
+  let awaited = false;
+  while (cursor.parent && (ts.isAwaitExpression(cursor.parent) || ts.isPropertyAccessExpression(cursor.parent) || ts.isCallExpression(cursor.parent))) {
+    cursor = cursor.parent;
+    if (ts.isAwaitExpression(cursor)) awaited = true;
+    if (ts.isCallExpression(cursor) && ts.isPropertyAccessExpression(cursor.expression) && cursor.expression.name.text === 'compile') compiled = true;
+  }
+  if (!compiled || !awaited) return null;
+  const declaration = cursor.parent;
+  return declaration && ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) ? declaration.name.text : null;
+}
+
+/** The subject variable receiving module.get, whether declared there or assigned in beforeEach. */
+function retrievedVariable(ts, call) {
+  let cursor = call;
+  while (cursor.parent && (ts.isAwaitExpression(cursor.parent) || ts.isParenthesizedExpression(cursor.parent))) cursor = cursor.parent;
+  const parent = cursor.parent;
+  if (parent && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) return parent.name.text;
+  if (parent && ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(parent.left)) return parent.left.text;
+  return null;
+}
+
+/** A helper returning the retrieved subject is followed to the variable receiving its result. */
+function retrievedSubjects(ts, read, sourceFile) {
+  const direct = retrievedVariable(ts, read);
+  if (direct) return [direct];
+  if (!read.parent || !ts.isReturnStatement(read.parent)) return [];
+  let helper = read.parent;
+  while (helper.parent && !ts.isFunctionLike(helper)) helper = helper.parent;
+  const name = helper.name?.text ?? helper.parent?.name?.text;
+  if (!name) return [];
+  return matchingNodes(ts, sourceFile, node => ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === name)
+    .map(node => retrievedVariable(ts, node)).filter(Boolean);
+}
+
+/** The same compiled module retrieves the matching token and its result actually calls a subject function. */
+function retrievedSubjectUsed(ts, call, token, names) {
+  const moduleName = initializedVariable(ts, call);
+  if (!moduleName) return false;
+  const sourceFile = call.getSourceFile();
+  const reads = matchingNodes(ts, sourceFile, node => {
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) return false;
+    const member = node.expression;
+    return ts.isIdentifier(member.expression) && member.expression.text === moduleName && member.name.text === 'get'
+      && node.arguments.length === 1 && ts.isIdentifier(node.arguments[0]) && node.arguments[0].text === token.text;
+  });
+  return reads.some(read => {
+    const subjects = retrievedSubjects(ts, read, sourceFile);
+    return matchingNodes(ts, sourceFile, node => ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)
+      && ts.isIdentifier(node.expression.expression) && subjects.includes(node.expression.expression.text) && names.includes(node.expression.name.text)).length > 0;
+  });
+}
+
+/** A pure function service has exactly one real subject value provider, retrieved and exercised through Nest. */
+export function checkFunctionSubject({ ts, rel, serviceRel, imports, call, list, names, report }) {
+  const provider = list.elements[0];
+  const shape = provider && ts.isObjectLiteralExpression(provider) && provider.properties.length === 2;
+  const token = shape ? propertyValue(ts, provider, 'provide') : null;
+  const value = shape ? propertyValue(ts, provider, 'useValue') : null;
+  if (list.elements.length !== 1 || !token || !ts.isIdentifier(token) || !realFunctions(ts, value, names, imports, rel, serviceRel)) {
+    report(provider ?? list, `${rel}: a function-only subject needs exactly one { provide: TOKEN, useValue: { ...realFunctions } } provider containing every callable export imported from ./${path.posix.basename(serviceRel, '.ts')}.`);
+    return;
+  }
+  if (!retrievedSubjectUsed(ts, call, token, names)) report(list, `${rel}: retrieve the function subject with moduleRef.get(TOKEN) from this compiled testing module and exercise a function on the returned subject.`);
+}

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

@@ -297,11 +297,11 @@ function checkTestTopology(state) {
   // Test kinds and folders that do not exist: int-spec, harness-spec, src/tests/harness and live/;
   // a backend spec sits by its kind (beside its subject, or under src/tests/{integration,e2e,contract}/).
   for (const file of state.tree.files()) {
-    if (UNSUPPORTED_TEST_SUFFIX.test(file))
+    if (state.backend && state.profile === 'be' && UNSUPPORTED_TEST_SUFFIX.test(file))
       state.finding('BE_TEST_TOPOLOGY', file, `${file} uses an unsupported test kind. Only unit *.spec.ts, *.integration-spec.ts, *.e2e-spec.ts and *.contract-spec.ts exist, each in its own folder under src/tests/.`);
-    else if (state.backend && UNSUPPORTED_TEST_FOLDER.test(file))
+    else if (state.backend && state.profile === 'be' && UNSUPPORTED_TEST_FOLDER.test(file))
       state.finding('BE_TEST_TOPOLOGY', file, `${file} sits in an unsupported test folder. Unit specs sit beside their subject, flows go under src/tests/e2e/<area>/ and test infrastructure under src/tests/world/.`);
-    else if (state.backend && file.startsWith('src/tests/') && isExtraTestConfig(file))
+    else if (state.backend && state.profile === 'be' && file.startsWith('src/tests/') && isExtraTestConfig(file))
       state.finding('BE_TEST_TOPOLOGY', file, `${file} is a per-lane test config. One root jest.config.js declares exactly the unit, integration, e2e and contract projects.`);
   }
 }

package/runtime/scripts/hfs/architecture/i18n-keys.mjs

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { byCodeUnit } from '../../lib/list.mjs';
+import { escapeRegExp } from '../../lib/regex.mjs';
 
 /**
  * R106 `i18n-keys` (FE_I18N_KEYS). The catalogs of an app (`apps/<app>/src/modules/i18n/messages/<locale>.json`, slot fe.modules.i18n) and
@@ -12,7 +13,7 @@ import { byCodeUnit } from '../../lib/list.mjs';
  *     own source (both branches of a conditional key are read). A key no locale's catalog holds is FE_I18N_KEYS, once per call. A computed
  *     key (a template with an interpolation, a variable) is not judged here; it counts as a read.
  *   - a key nobody reads is dead: a leaf of the app's catalogs that no string in the app's or the shared packages' source can be reading.
- *     A leaf counts as read when a string literal or a template pattern (each interpolation a wildcard segment) of that source equals a
+ *     A leaf counts as read when a string literal or a template pattern (each interpolation a wildcard within its dotted segment) equals a
  *     tail of its dotted path (`"title"`, `"card.title"`, `"orders.card.title"` all read `orders.card.title`); the test is deliberately loose
  *     so a key handed through props or a table of keys is never reported, and only a key that appears nowhere is.
  *
@@ -39,7 +40,10 @@ const held = (leaves, full) => leaves.has(full) || [...leaves].some(leaf => leaf
 
 // A pattern that is only wildcards (`${a}`, `${a}.${b}`) names nothing: it would read every key, so it reads none.
 const tailMatches = (pattern, leafSegments) => pattern.some(segment => segment !== '*' && segment !== '') && pattern.length <= leafSegments.length
-  && pattern.every((segment, index) => segment === '*' || segment === leafSegments[leafSegments.length - pattern.length + index]);
+  && pattern.every((segment, index) => {
+    const leaf = leafSegments[leafSegments.length - pattern.length + index];
+    return segment instanceof RegExp ? segment.test(leaf) : segment === '*' || segment === leaf;
+  });
 
 function catalogsPerApp(config, graph) {
   const catalogs = new Map();
@@ -56,12 +60,21 @@ function catalogsPerApp(config, graph) {
   return catalogs;
 }
 
+/** Each interpolation can fill part or all of a segment; the template's static fragments keep their literal spelling. */
+function templatePatternOf(node) {
+  return [node.head.text, ...node.templateSpans.map(span => span.literal.text)].join('\u0000').split('.').map(segment => {
+    if (!segment.includes('\u0000')) return segment;
+    const parts = segment.split('\u0000');
+    return parts.every(part => part === '') ? '*' : new RegExp(`^${parts.map(escapeRegExp).join('.*')}$`, 'su');
+  });
+}
+
 function patternsOf(ts, files) {
   const patterns = [];
   for (const file of files) {
     const visit = node => {
       if (ts.isStringLiteralLike(node)) patterns.push(node.text.split('.'));
-      else if (ts.isTemplateExpression(node)) patterns.push([node.head.text, ...node.templateSpans.map(span => span.literal.text)].join('\u0000').replaceAll('\u0000', '*').split('.'));
+      else if (ts.isTemplateExpression(node)) patterns.push(templatePatternOf(node));
       ts.forEachChild(node, visit);
     };
     visit(file.sourceFile);

package/runtime/scripts/hfs/architecture/machine-ast.mjs

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { canonical } from './config.mjs';
 import { hasAnyFlag, sourceLocation } from '../../lib/ts-ast.mjs';
+import { byCodeUnit } from '../../lib/list.mjs';
 
 const HELPER_DEPTH = 4;
 
@@ -110,6 +111,21 @@ const at = (env, rel, sourceFile, node, extra = {}) => ({ path: rel, ...sourceLo
 /** The app root file of an app (apps/<name>/src/app.module.ts), or null when the program does not hold it. */
 const appRoot = (env, name) => graphFile(env, `apps/${name}/src/app.module.ts`);
 
+/**
+ * Whether a repository-relative file is a composition group of an app: `apps/<app>/src/compose/<area>.ts`, the module list of
+ * one area that the app root spreads into its imports (slot allows `compose/<area>.ts` of every be.app.* slot).
+ */
+export const isComposeGroup = rel => /^apps\/[^/]+\/src\/compose\/[^/]+\.ts$/.test(rel) && !/\.(?:spec|d)\.ts$/.test(rel);
+
+/** The app root and the composition groups of an app, in path order (the root first); [] when the program holds no root. */
+const appCompositionFiles = (env, name) => {
+  const root = appRoot(env, name);
+  if (!root) return [];
+  const prefix = `apps/${name}/src/compose/`;
+  const groups = [...env.graph.files.values()].filter(file => file.rel.startsWith(prefix) && isComposeGroup(file.rel));
+  return [root, ...groups.sort((a, b) => byCodeUnit(a.rel, b.rel))];
+};
+
 /** The body a call or a spread identifier resolves to when it is a function or a const declared in a file of the program (not a package), else null. */
 function helperBodyOf(env, checker, node) {
   const { ts } = env;
@@ -200,6 +216,7 @@ export function machineKit({ context, graph }) {
     valueOfProperty: bound(valueOfProperty),
     at: bound(at),
     appRoot: bound(appRoot),
+    appCompositionFiles: bound(appCompositionFiles),
   };
 }
 

package/runtime/scripts/hfs/architecture/module-per-transport.mjs

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { machineKit } from './machine-ast.mjs';
+import { isComposeGroup, machineKit } from './machine-ast.mjs';
 import { treeOf } from './required-files.mjs';
 import { byCodeUnit } from '../../lib/list.mjs';
 import { trimTrailingSlashes } from '../trailing-slashes.mjs';
@@ -7,14 +7,17 @@ import { trimTrailingSlashes } from '../trailing-slashes.mjs';
 /**
  * R45 `module-per-transport` (BE_MODULE_SHAPE, BE-CONVENTION 1.2 and 1.6). A feature has one Nest module for its
  * application (`<f>.module.ts` at the feature root) and exactly one module per transport folder
- * (`transport/<protocol>/<f>-<protocol>.module.ts`). Never one module per operation, never a module-definition in a feature:
+ * (`transport/<protocol>/<f>-<protocol>.module.ts`). Never one module per operation. Every one of these modules has its own
+ * module-definition beside it (owner ruling module-definition-everywhere, R295):
  *
- *   - a `*.module.ts` file below a transport folder other than `<f>-<protocol>.module.ts`, a `*.module-definition.ts`
- *     anywhere in a feature, and an `@Module` class (or a `ConfigurableModuleBuilder`/`ConfigurableModuleClass` use) in a
- *     feature file that is neither the application module nor the transport module of its own folder are refused;
+ *   - a `*.module.ts` file below a transport folder other than `<f>-<protocol>.module.ts`, a `*.module-definition.ts` that is
+ *     not the sibling of the application module or of the transport module of its own folder, and an `@Module` class (or a
+ *     `ConfigurableModuleBuilder`/`ConfigurableModuleClass` use) in a feature file that is neither the application module, the
+ *     transport module of its own folder nor that module's definition are refused;
  *   - apps import only transport modules, of the kinds their app kind allows: the `composedBy` list of each transport slot
- *     in knowledge/hfs/slots.yaml (api: graphql, http, websocket; worker: schedule, message). An app root that
- *     lists a feature's application module, or the transport module of another kind, is refused;
+ *     in knowledge/hfs/slots.yaml (api: graphql, http, websocket; worker: schedule, message). An app root (app.module.ts
+ *     or a composition group of its compose/ folder) that lists a feature's application module, or the transport module
+ *     of another kind, is refused;
  *   - a composed root (an owner slot with `composedBy`, be.cli) holds one static module per folder, named after the folder
  *     (cli.module.ts, <group>/<group>.module.ts); an app of a composing kind lists the root module only, and an app of any
  *     other kind lists none of its modules.
@@ -22,7 +25,6 @@ import { trimTrailingSlashes } from '../trailing-slashes.mjs';
 export const MODULE_PER_TRANSPORT_RULE_IDS = ['BE_MODULE_SHAPE'];
 
 const RULE = 'BE_MODULE_SHAPE';
-const APP_ROOT_FILE = 'app.module.ts';
 
 function featureOwnerOf(resolver, rel) {
   const owner = resolver.ownerOf(rel);
@@ -53,13 +55,24 @@ function composedByProtocol(resolver) {
   return composedBy;
 }
 
-function reportTransportFileShapes(tree, placeOf, plain) {
+/** The module a feature file may declare: the application module, the transport module of its folder, or a cli folder's module. */
+function ownModuleOf(place, rel, composedModuleOf) {
+  if (place.composed) return composedModuleOf(rel);
+  return place.protocol === null
+    ? `${place.root}/${place.feature}.module.ts`
+    : `${place.root}/transport/${place.protocol}/${place.feature}-${place.protocol}.module.ts`;
+}
+
+const DEFINITION_FILE = /\.module-definition\.[cm]?tsx?$/u;
+const definitionOf = modulePath => modulePath.replace(/\.module\.([cm]?tsx?)$/u, '.module-definition.$1');
+
+function reportTransportFileShapes(tree, placeOf, plain, composedModuleOf) {
   let transportModules = 0;
   for (const rel of [...tree.files].sort(byCodeUnit)) {
     const place = placeOf(rel);
     if (!place) continue;
     const base = path.posix.basename(rel);
-    if (/\.module-definition\.[cm]?tsx?$/u.test(base)) plain(rel, `${rel} is a module-definition inside feature ${place.feature}; a feature module is a static \`@Module\`, and only capabilities under src/modules build their module from a definition. Delete it and list the providers in the module.`, { feature: place.feature });
+    if (DEFINITION_FILE.test(base) && rel !== definitionOf(ownModuleOf(place, rel, composedModuleOf))) plain(rel, `${rel} is a module-definition that is not beside a module of feature ${place.feature}; the definition of a module is its sibling ${path.posix.basename(definitionOf(ownModuleOf(place, rel, composedModuleOf)))}, one per application module, transport module or cli folder.`, { feature: place.feature });
     if (place.protocol && /\.module\.[cm]?tsx?$/u.test(base)) {
       const expected = `${place.feature}-${place.protocol}.module.ts`;
       if (place.below.length !== 3 || base !== expected) plain(rel, `${rel} is a second module of the ${place.protocol} transport of ${place.feature}; a transport folder has exactly one module, transport/${place.protocol}/${expected}, never one module per operation. List the operation's providers in that module and delete this file.`, { feature: place.feature, protocol: place.protocol });
@@ -88,13 +101,15 @@ function reportModuleClassLocation(file, statement, place, composedModuleOf, rep
   if (file.rel !== own) report(file, statement.name, `${statement.name.text} is a Nest module declared in ${file.rel}; a feature declares exactly its application module (${place.feature}.module.ts) and one module per transport folder (${place.feature}-<protocol>.module.ts), never a module per operation.`, { feature: place.feature });
 }
 
-function reportConfigurableModuleUses(file, checker, kit, ts, place, report) {
+function reportConfigurableModuleUses(file, checker, kit, ts, place, env) {
+  const own = ownModuleOf(place, file.rel, env.composedModuleOf);
+  const isDefinition = file.rel === definitionOf(own);
   kit.walk(file.sourceFile, node => {
-    if (ts.isNewExpression(node) && kit.isImportOf(checker, node.expression, 'ConfigurableModuleBuilder', '@nestjs/common')) {
-      report(file, node, `ConfigurableModuleBuilder builds a capability's module definition; feature ${place.feature} has static modules only, so declare the providers in its @Module.`, { feature: place.feature });
-    } else if (ts.isHeritageClause(node)) {
+    if (ts.isNewExpression(node) && kit.isImportOf(checker, node.expression, 'ConfigurableModuleBuilder', '@nestjs/common') && !isDefinition) {
+      env.report(file, node, `ConfigurableModuleBuilder builds the module definition of one module; in feature ${place.feature} it is written only in ${path.posix.basename(definitionOf(own))}, beside ${path.posix.basename(own)}.`, { feature: place.feature });
+    } else if (ts.isHeritageClause(node) && file.rel !== own) {
       for (const type of node.types) if (kit.isImportOf(checker, type.expression, 'ConfigurableModuleClass', '@nestjs/common')) {
-        report(file, type, `A feature module never extends ConfigurableModuleClass; feature ${place.feature} has static modules only.`, { feature: place.feature });
+        env.report(file, type, `ConfigurableModuleClass is extended by the module of its own definition only (${path.posix.basename(own)}); feature ${place.feature} declares no other configurable module.`, { feature: place.feature });
       }
     }
     return true;
@@ -118,7 +133,7 @@ function collectFeatureModules(graph, kit, ts, placeOf, composedModuleOf, report
     const checker = kit.checkerOf(file.sourceFile);
     const place = placeOf(file.rel);
     moduleClassesInFile(file, checker, place, modules, env);
-    if (place) reportConfigurableModuleUses(file, checker, kit, ts, place, report);
+    if (place) reportConfigurableModuleUses(file, checker, kit, ts, place, env);
   }
   return modules;
 }
@@ -152,28 +167,37 @@ function inspectModuleDeclarations(checker, target, node, root, app, scan, seen)
   return references;
 }
 
-function inspectAppRoot(app, scan) {
-  const { graph, kit, ts } = scan;
-  const root = graph.files.get(`apps/${app.name}/src/${APP_ROOT_FILE}`);
-  if (!root) return 0;
-  const checker = kit.checkerOf(root.sourceFile);
-  const seen = new Set();
+/** The module references of one composition file: the root's `imports` lists, or every array of a composition group (its module list). */
+function inspectCompositionFile(file, app, scan, seen) {
+  const { kit, ts } = scan;
+  const checker = kit.checkerOf(file.sourceFile);
+  const group = isComposeGroup(file.rel);
   let references = 0;
   const judge = node => {
     const call = ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register';
     if (ts.isCallExpression(node) && !call) return;
     const target = call ? node.expression.expression : node;
-    references += inspectModuleDeclarations(checker, target, node, root, app, scan, seen);
+    references += inspectModuleDeclarations(checker, target, node, file, app, scan, seen);
   };
-  kit.walk(root.sourceFile, node => {
+  kit.walk(file.sourceFile, node => {
     if (ts.isPropertyAssignment(node) && kit.propertyNameText(node.name) === 'imports' && ts.isArrayLiteralExpression(node.initializer)) {
       for (const element of node.initializer.elements) judge(element);
+    } else if (group && ts.isArrayLiteralExpression(node)) {
+      for (const element of node.elements) judge(element);
     } else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register') judge(node);
     return true;
   });
   return references;
 }
 
+/** The module references of an app: its root `apps/<app>/src/app.module.ts` and the composition groups of `compose/` it spreads. */
+function inspectAppRoot(app, scan) {
+  const seen = new Set();
+  let references = 0;
+  for (const file of scan.kit.appCompositionFiles(app.name)) references += inspectCompositionFile(file, app, scan, seen);
+  return references;
+}
+
 function appModuleReferences(apps, scan) {
   let references = 0;
   for (const app of apps) references += inspectAppRoot(app, scan);
@@ -194,7 +218,7 @@ export function checkModulePerTransport(input) {
   const composedBy = composedByProtocol(resolver);
 
   const tree = treeOf(config.root);
-  const transportModules = reportTransportFileShapes(tree, placeOf, plain);
+  const transportModules = reportTransportFileShapes(tree, placeOf, plain, composedModuleOf);
 
   const modules = collectFeatureModules(graph, kit, ts, placeOf, composedModuleOf, report);
 

package/runtime/scripts/hfs/architecture/next-data-inference.mjs

@@ -0,0 +1,176 @@
+// Infer lexical request identities for SWR hooks without a declared lifecycle contract.
+import { unwrapExpression } from './typescript.mjs';
+import { anyDescendant, normalizedSymbol } from './ast-walks.mjs';
+import { sourceLocation } from '../../lib/ts-ast.mjs';
+import { functionNode, constInitializer, inferredSymbol } from './next-data-symbols.mjs';
+
+export function inferredFetcher(ts, checker, expression, seen = new Set()) {
+  if (!expression) return null;
+  expression = unwrapExpression(ts, expression);
+  if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) return expression;
+  const symbol = normalizedSymbol(ts, checker, expression);
+  if (!symbol || seen.has(symbol)) return null;
+  for (const declaration of symbol.getDeclarations?.() ?? []) {
+    const fn = functionNode(ts, declaration);
+    if (fn) return fn;
+  }
+  const initializer = constInitializer(ts, symbol);
+  return initializer ? inferredFetcher(ts, checker, initializer, new Set(seen).add(symbol)) : null;
+}
+
+function importedIdentityReference(ts, checker, expression) {
+  const reference = ts.isShorthandPropertyAssignment(expression.parent)
+    ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
+  return (reference?.getDeclarations?.() ?? []).some(declaration => ts.isImportSpecifier(declaration)
+    || ts.isImportClause(declaration) || ts.isNamespaceImport(declaration) || ts.isImportEqualsDeclaration(declaration));
+}
+
+function identifierIdentityAccess(ts, checker, expression, seen) {
+  const imported = importedIdentityReference(ts, checker, expression);
+  const symbol = inferredSymbol(ts, checker, expression);
+  const initializer = symbol && !seen.has(symbol) ? constInitializer(ts, symbol) : null;
+  if (initializer) {
+    const alias = identityAccess(ts, checker, initializer, new Set(seen).add(symbol));
+    if (alias) return { ...alias, imported: imported || alias.imported };
+  }
+  return { symbol, parts: [expression.text], imported };
+}
+
+function isSelectedMember(ts, expression) {
+  return ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)
+    && ts.isStringLiteralLike(expression.argumentExpression);
+}
+
+function selectedMemberKey(ts, expression) {
+  return ts.isPropertyAccessExpression(expression) ? expression.name.text : expression.argumentExpression.text;
+}
+
+function identityAccess(ts, checker, expression, seen = new Set()) {
+  expression = unwrapExpression(ts, expression);
+  if (ts.isIdentifier(expression)) return identifierIdentityAccess(ts, checker, expression, seen);
+  if (isSelectedMember(ts, expression)) {
+    const base = identityAccess(ts, checker, expression.expression, seen);
+    return base ? { ...base, parts: [...base.parts, selectedMemberKey(ts, expression)] } : null;
+  }
+  return null;
+}
+
+function containerWritten(ts, checker, symbol, source) {
+  const rootSymbol = expression => {
+    expression = unwrapExpression(ts, expression);
+    while (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) expression = unwrapExpression(ts, expression.expression);
+    return ts.isIdentifier(expression) ? inferredSymbol(ts, checker, expression) : null;
+  };
+  return anyDescendant(ts, source, node => {
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment
+      && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) return rootSymbol(node.left) === symbol;
+    if (ts.isDeleteExpression(node)) return rootSymbol(node.expression) === symbol;
+    if (ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)
+      && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(node.operator)) return rootSymbol(node.operand) === symbol;
+    return false;
+  });
+}
+
+function selectedRequestAlias(ts, checker, expression, seen) {
+  const symbol = inferredSymbol(ts, checker, expression);
+  const initializer = symbol && !seen.has(symbol) ? constInitializer(ts, symbol) : null;
+  if (!initializer) return null;
+  const value = unwrapExpression(ts, initializer);
+  if (ts.isObjectLiteralExpression(value) && (initializer.getSourceFile() !== expression.getSourceFile()
+    || containerWritten(ts, checker, symbol, expression.getSourceFile()))) return null;
+  if (ts.isObjectLiteralExpression(value) || ts.isIdentifier(value) || ts.isPropertyAccessExpression(value)
+    || ts.isElementAccessExpression(value)) return { symbol, value };
+  return null;
+}
+
+function selectedRequestProperty(ts, object, key) {
+  if (!ts.isObjectLiteralExpression(object) || !object.properties.every(property => ts.isPropertyAssignment(property)
+    || ts.isShorthandPropertyAssignment(property))) return null;
+  return [...object.properties].reverse().find(candidate => (ts.isIdentifier(candidate.name)
+    || ts.isStringLiteralLike(candidate.name)) && candidate.name.text === key) ?? null;
+}
+
+function selectedRequestValue(ts, checker, expression, seen = new Set()) {
+  expression = unwrapExpression(ts, expression);
+  if (ts.isIdentifier(expression)) {
+    const alias = selectedRequestAlias(ts, checker, expression, seen);
+    return alias ? selectedRequestValue(ts, checker, alias.value, new Set(seen).add(alias.symbol)) : expression;
+  }
+  if (!isSelectedMember(ts, expression)) return expression;
+  const object = selectedRequestValue(ts, checker, expression.expression, seen);
+  const property = selectedRequestProperty(ts, object, selectedMemberKey(ts, expression));
+  if (!property) return expression;
+  const value = ts.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+  return selectedRequestValue(ts, checker, value, seen);
+}
+
+function capturedInput(ts, access, region) {
+  const declarations = access.symbol?.getDeclarations?.() ?? [];
+  return declarations.some(declaration => {
+    if (declaration.getSourceFile() === region.getSourceFile() && declaration.pos >= region.pos && declaration.end <= region.end) return false;
+    if (declaration.getSourceFile().isDeclarationFile && !access.imported) return false;
+    return access.imported || ts.isVariableDeclaration(declaration) || ts.isParameter(declaration) || ts.isBindingElement(declaration);
+  });
+}
+
+function capturedIdentityAlias(ts, access, seen) {
+  // Follow transparent aliases and request objects, so {id} and an alias of id carry the same identity.
+  if (access.parts.length !== 1 || seen.has(access.symbol)) return null;
+  const initializer = constInitializer(ts, access.symbol);
+  if (!initializer) return null;
+  const value = unwrapExpression(ts, initializer);
+  return ts.isCallExpression(value) || ts.isAwaitExpression(value) || ts.isNewExpression(value) ? null : value;
+}
+
+function recordInferredIdentity(scope, access, seen, visit) {
+  const { ts, call, region, reasons, identities } = scope;
+  if (access?.imported && !(access.symbol?.getDeclarations?.() ?? []).length) {
+    reasons.push(`${call.source.fileName}:${sourceLocation(call.source, call.node).line} imported SWR request input ${access.parts.join('.')} cannot be resolved; dataLifecycle is required to declare identities`);
+    return true;
+  }
+  if (!access || !capturedInput(ts, access, region)) return false;
+  const alias = capturedIdentityAlias(ts, access, seen);
+  if (alias) visit(alias, new Set(seen).add(access.symbol));
+  else {
+    const binding = access.parts.join('.');
+    identities.set(binding, { id: binding, binding, ...access, gatesRequest: false, resource: call.kind === 'mutation' });
+  }
+  return true;
+}
+
+function visitRequestChildren(ts, node, seen, visit) {
+  if (ts.isPropertyAssignment(node)) { visit(node.initializer, seen); return; }
+  // A method name is not a request input; its receiver and arguments can be.
+  if (ts.isCallExpression(node)) {
+    const callee = unwrapExpression(ts, node.expression);
+    if (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee)) visit(callee.expression, seen);
+    for (const argument of node.arguments) visit(argument, seen);
+    return;
+  }
+  if (ts.isVariableDeclaration(node)) {
+    if (node.initializer) visit(node.initializer, seen);
+    return;
+  }
+  ts.forEachChild(node, child => { visit(child, seen); });
+}
+
+/** Infer lexical request inputs; parameters declared inside the fetcher are supplied by SWR. */
+export function inferredIdentities(context, call, region, reasons) {
+  const { ts } = context;
+  const identities = new Map();
+  const scope = { ts, call, region, reasons, identities };
+  const visit = (node, seen = new Set()) => {
+    const selectedValue = selectedRequestValue(ts, call.checker, node);
+    if (selectedValue !== node && selectedValue !== unwrapExpression(ts, node)) { visit(selectedValue, seen); return; }
+    if (recordInferredIdentity(scope, identityAccess(ts, call.checker, node), seen, visit)) return;
+    visitRequestChildren(ts, node, seen, visit);
+  };
+  visit(region.body ?? region);
+  return [...identities.values()];
+}
+
+export function inferredKeyBindings(context, call, reasons) {
+  const key = call.node.arguments[0];
+  // A key or its null guard can contain bindings that are not captured request inputs.
+  return key ? inferredIdentities(context, call, key, reasons).map(identity => ({ ...identity, id: `key:${identity.id}`, resource: false })) : [];
+}

package/runtime/scripts/hfs/architecture/next-data-symbols.mjs

@@ -0,0 +1,26 @@
+// Symbol reads shared by declared and inferred SWR lifecycle checks.
+import { unwrapExpression } from './typescript.mjs';
+import { normalizedSymbol, normalizedSymbolValue } from './ast-walks.mjs';
+import { isConstVariable } from '../../lib/ts-ast.mjs';
+
+export function functionNode(ts, declaration) {
+  if (ts.isFunctionDeclaration(declaration) && declaration.body) return declaration;
+  if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+    const value = unwrapExpression(ts, declaration.initializer);
+    if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) return value;
+  }
+  return null;
+}
+
+export function constInitializer(ts, symbol) {
+  const declarations = symbol?.getDeclarations?.() ?? [];
+  if (declarations.length !== 1 || !ts.isVariableDeclaration(declarations[0]) || !declarations[0].initializer
+    || !isConstVariable(ts, declarations[0])) return null;
+  return declarations[0].initializer;
+}
+
+export function inferredSymbol(ts, checker, node) {
+  return ts.isIdentifier(node) && ts.isShorthandPropertyAssignment(node.parent)
+    ? normalizedSymbolValue(ts, checker, checker.getShorthandAssignmentValueSymbol(node.parent))
+    : normalizedSymbol(ts, checker, node);
+}