@starci/eslint-canon-fe 8.3.0 → 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/module-per-transport.mjs

@@ -7,11 +7,13 @@ 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 (app.module.ts
  *     or a composition group of its compose/ folder) that lists a feature's application module, or the transport module
@@ -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;
 }
@@ -203,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);
+}

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

@@ -3,9 +3,11 @@ import { canonical, isInside } from './config.mjs';
 import { parseContract, installedSWR } from './next-data-contract.mjs';
 import { relativePath, unwrapExpression } from './typescript.mjs';
 import { anyDescendant, normalizedSymbol, normalizedSymbolValue, valueSymbol as sharedValueSymbol } from './ast-walks.mjs';
-import { isConstVariable, sourceLocation } from '../../lib/ts-ast.mjs';
+import { sourceLocation } from '../../lib/ts-ast.mjs';
 import { byCodeUnit } from '../../lib/list.mjs';
 import { createNextDataKeyInspector } from './next-data-key.mjs';
+import { functionNode, constInitializer, inferredSymbol } from './next-data-symbols.mjs';
+import { inferredFetcher, inferredIdentities, inferredKeyBindings } from './next-data-inference.mjs';
 export const SWR_KEY_RULE_ID = 'FE_SWR_KEY_IDENTITY';
 export const SWR_MUTATION_RULE_ID = 'FE_SWR_MUTATION_RESOURCE_IDENTITY';
 export const SWR_DATA_RULE_IDS = [SWR_KEY_RULE_ID, SWR_MUTATION_RULE_ID];
@@ -155,15 +157,6 @@ function discoverCalls(config, context, targets) {
   return calls;
 }
 
-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;
-}
-
 function exportedHook(config, context, entry, reasons) {
   const source = context.files.find(candidate => canonical(candidate.fileName) === canonical(path.join(config.root, ...entry.path.split('/'))));
   if (!source) {
@@ -223,19 +216,15 @@ function resolvedIdentities(ts, checker, fn, entry, reasons) {
   return identities.length === entry.identities.length ? identities : null;
 }
 
-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;
-}
-
 function violation(config, call, ruleId, message, extra = {}) {
   return { ruleId, path: relativePath(config.root, call.source.fileName), ...sourceLocation(call.source, call.node), message, ...extra };
 }
 
-const inspectKey = createNextDataKeyInspector({ anyDescendant, normalizedSymbol, unwrapExpression, constInitializer, sourceLocation, violation,
-  SWR_KEY_RULE_ID, SWR_MUTATION_RULE_ID });
+const keyInspectorDependencies = { anyDescendant, normalizedSymbol, unwrapExpression, constInitializer, sourceLocation, violation,
+  SWR_KEY_RULE_ID, SWR_MUTATION_RULE_ID };
+const inspectKey = createNextDataKeyInspector(keyInspectorDependencies);
+
+const inspectInferredKey = createNextDataKeyInspector({ ...keyInspectorDependencies, normalizedSymbol: inferredSymbol });
 
 function isUnshadowedCommonJsRequire(ts, checker, expression, seen = new Set(), depth = 0) {
   expression = unwrapExpression(ts, expression);
@@ -372,7 +361,26 @@ function lifecycleCoverage(ruleIds, contract, installed, calls, details) {
       swr: { name: installed.name, version: installed.version, major: installed.major } };
 }
 
-/** Check explicitly declared SWR lifecycle keys against the target program and installed SWR identity. */
+function inspectDefaultLifecycle(config, context, installed, lifecycleCalls, violations, reasons) {
+  for (const call of lifecycleCalls) {
+    const fetcher = inferredFetcher(context.ts, call.checker, call.node.arguments[1]);
+    if (!fetcher) {
+      reasons.push(`${relativePath(config.root, call.source.fileName)}:${sourceLocation(call.source, call.node).line} fetcher inputs cannot be inferred; dataLifecycle is required to declare identities`);
+      continue;
+    }
+    const entry = { id: `swr:${relativePath(config.root, call.source.fileName)}:${sourceLocation(call.source, call.node).line}`,
+      path: relativePath(config.root, call.source.fileName), export: call.owner?.name?.text ?? '<inferred hook>', kind: call.kind };
+    const identities = inferredIdentities(context, call, fetcher, reasons);
+    const selected = new Set(identities.map(identity => identity.id));
+    const findings = [];
+    inspectInferredKey(config, context, entry, call, [...identities, ...inferredKeyBindings(context, call, reasons)], findings, reasons);
+    violations.push(...findings.filter(finding => finding.identity === undefined || selected.has(finding.identity)));
+  }
+  const details = [...new Set(reasons)].sort(byCodeUnit);
+  return { violations, coverage: lifecycleCoverage([...SWR_DATA_RULE_IDS], { hooks: lifecycleCalls }, installed, lifecycleCalls.length, details) };
+}
+
+/** Check declared lifecycles, or infer captured request identities when production SWR has no declaration. */
 export function checkFrontendDataLifecycle(config, context) {
   const ruleIds = [...SWR_DATA_RULE_IDS];
   const references = swrReferences(config, context);
@@ -381,17 +389,17 @@ export function checkFrontendDataLifecycle(config, context) {
     return unavailableDataLifecycle(ruleIds, [String(error.message ?? error)]);
   }
   if (!contract && !references.found) return { violations: [], coverage: { status: 'not-applicable', ruleIds } };
-  if (!contract) return { violations: [], coverage: { status: 'unavailable', ruleIds,
-    details: ['package.json#starci.codePatterns.next.dataLifecycle is required when production source selects SWR', ...references.unsupported] } };
   const reasons = [];
   const violations = [];
   reasons.push(...references.unsupported);
+  if (!contract && references.unsupported.length) reasons.push('package.json#starci.codePatterns.next.dataLifecycle is required for unsupported SWR bindings');
   let installed;
   try { installed = installedSWR(config.packageRoot ?? config.root); } catch (error) {
     return { violations, coverage: { status: 'unavailable', ruleIds, details: [String(error.message ?? error)] } };
   }
-  if (installed.major !== contract.swr.major) reasons.push(`installed swr ${installed.version} does not match declared major ${contract.swr.major}`);
+  if (contract && installed.major !== contract.swr.major) reasons.push(`installed swr ${installed.version} does not match declared major ${contract.swr.major}`);
   const { lifecycleCalls } = lifecycleCallSets(config, context, installed, reasons);
+  if (!contract) return inspectDefaultLifecycle(config, context, installed, lifecycleCalls, violations, reasons);
   const { hookCache, entriesByHook } = hookEntries(config, context, contract, reasons);
   inspectHookLifecycle(config, context, lifecycleCalls, hookCache, entriesByHook, violations, reasons);
   addUndeclaredLifecycleReasons(config, lifecycleCalls, hookCache, reasons);

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

@@ -96,9 +96,23 @@ function checkBackend(graph) {
   const reached = reachFrom(graph, rootFiles);
   const violations = [];
   reportUncomposedBackendOwners(byUnit, reached, roots, counts, violations);
+  reportUncomposedTransports(graph, reached, roots, counts, violations);
   return { violations, coverage: { status: 'checked', ...counts } };
 }
 
+/** A reached feature does not compose its other transport modules. Judge each module's runtime path. */
+function reportUncomposedTransports(graph, reached, roots, counts, violations) {
+  for (const [rel, node] of graph.files) {
+    if (!node.owner || !rel.startsWith('src/features/') || TEST_FILE.test(rel)) continue;
+    if (!/\/transport\/[^/]+\/[^/]+\.module\.[cm]?[jt]sx?$/.test(rel) || reached.has(rel)) continue;
+    counts.notComposed += 1;
+    violations.push({
+      ruleId: 'BE_FEATURE_NOT_COMPOSED', path: rel, owner: node.owner.root, slot: node.slot, appRoots: roots,
+      message: `Transport module ${rel} is not composed into any app: no runtime import path leads from ${roots.join(', ')} to it (a type-only import composes nothing).`,
+    });
+  }
+}
+
 /** Route table of one app: arrays of segments, each {kind:'static'|'dyn'|'catch'|'optcatch', text}. */
 function routeSegmentsOf(parts) {
   const segments = [];

package/runtime/scripts/hfs/architecture/register-once.mjs

@@ -9,13 +9,13 @@ import { byCodeUnit } from '../../lib/list.mjs';
  * reference's `CodingModule imports DeviceModule` shape). Each capability has one representative module: the only module
  * of the capability an app registers, once, in `apps/<app>/src/app.module.ts` as `X.register({ isGlobal: true, ... })`, or in a
  * composition group `apps/<app>/src/compose/<area>.ts` the root spreads (an app root here means the root and its groups).
- * It may split itself into sub-modules imported as plain `imports: [Sub]`; a sub-module is never in an app and has one
+ * It may split itself into sub-modules imported as `imports: [Sub.register({})]`; a sub-module is never in an app and has one
  * importer, its parent. Over every `@Module` class of the program:
  *
  *   - a module in an app root's imports (a `X.register(...)` call or a listed class, helpers of the root included) is
  *     listed once there, is imported by no other module, and, when it is a capability module of src/modules, is registered
  *     with the literal `isGlobal: true` (a bare capability class is not a registration);
- *   - a module imported by a non-app module has exactly one importer and appears in no app root; the one exception is
+ *   - a module imported by a non-app module (as `Sub.register({})`) has exactly one importer and appears in no app root; the one exception is
  *     the feature case: a feature's application module is imported by each protocol module of the same feature;
  *   - `isGlobal: true` appears only in an app root.
  */