@starci/hfs 4.3.0 → 4.4.1

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.
  */

package/runtime/scripts/hfs/architecture/source-names.mjs

@@ -1,13 +1,14 @@
 import path from 'node:path';
 import { isInside } from './config.mjs';
 import { relativePath, unwrapExpression } from './typescript.mjs';
-import { commonJsRequireReasons, decoratorCallee, moduleExportsOf, nodeDecorators, normalizedSymbol, normalizedSymbolValue, programSourcesOf, returnedExpressions, selectedNode, valueSymbol, violation } from './ast-walks.mjs';
+import { commonJsRequireReasons, constructedDecoratorKind, decoratorCallee, moduleExportsOf, mutableDecoratorKind, nodeDecorators, normalizedSymbol, normalizedSymbolValue, programSourcesOf, returnedExpressions, selectedNode, valueSymbol, violation } from './ast-walks.mjs';
 import { createBackendSourceShapeChecker } from './source-names-shape.mjs';
+import { byCodeUnit } from '../../lib/list.mjs';
 
 const SOURCE_LAYOUT_RULE_ID = 'BE_FEATURE_LAYOUT_INVALID';
 const SOURCE_NAME_RULE_ID = 'BE_SOURCE_FORM';
 const FRAMEWORK_EXPORTS = new Map([
-  ['@nestjs/graphql', new Set(['Args', 'ArgsType', 'InputType', 'Mutation', 'ObjectType', 'Query', 'registerEnumType'])],
+  ['@nestjs/graphql', new Set(['Args', 'ArgsType', 'InputType', 'Mutation', 'ObjectType', 'Query', 'Subscription', 'registerEnumType'])],
   ['typeorm', new Set(['Entity', 'EntitySchema', 'MigrationInterface', 'ViewEntity'])],
 ]);
 const APPLICATION_ROLES = new Set(['command', 'contracts', 'handler', 'query']);
@@ -237,6 +238,11 @@ function graphqlField({ config, context, sourceFile, node, decorator, kind, nami
   }
   const methodName = node.name && (context.ts.isIdentifier(node.name) || context.ts.isStringLiteralLike(node.name)) ? node.name.text : null;
   const name = selected.status === 'literal' ? selected.value : methodName;
+  if (selected.status === 'literal') {
+    if (!methodName) namingReasons.push(`${relativePath(config.root, sourceFile.fileName)} cannot prove the @${kind} method name`);
+    else if (selected.value !== methodName) violations.push(violation(config, sourceFile, selected.node, SOURCE_NAME_RULE_ID,
+      `GraphQL @${kind} field name ${selected.value} must equal its method name ${methodName}.`));
+  }
   if (!name) namingReasons.push(`${relativePath(config.root, sourceFile.fileName)} cannot prove the @${kind} field name`);
   else if (!camelCase(name)) violations.push(violation(config, sourceFile, selected.node ?? node.name ?? node, SOURCE_NAME_RULE_ID,
     `GraphQL field name ${name} must be camelCase.`));
@@ -316,7 +322,46 @@ const checkBackendSourceShapeImpl = createBackendSourceShapeChecker({
   TRACE_NEW,
 });
 
+function inspectSubscriptionSource({ config, context, sourceFile, checker, framework, configuredRoot, namingReasons, violations }) {
+  const visit = node => {
+    for (const decorator of nodeDecorators(context.ts, node)) {
+      const kind = decoratorKind(context.ts, checker, decorator, framework.bySymbol);
+      if (kind === 'Subscription') graphqlField({ config, context, sourceFile, node, decorator, kind, namingReasons, violations });
+      else if (!kind && !configuredRoot) {
+        const dynamic = mutableDecoratorKind(context.ts, checker, decorator, framework.bySymbol)
+          ?? constructedDecoratorKind(context.ts, checker, decorator, framework.bySymbol, TRACE_NEW);
+        if (['Subscription', 'multiple framework', 'unproven framework'].includes(dynamic)) {
+          namingReasons.push(`${relativePath(config.root, sourceFile.fileName)} uses a mutable or constructed ${dynamic} decorator identity`);
+        }
+      }
+    }
+    context.ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+}
+
 export function checkBackendSourceShape(config, context) {
-  return checkBackendSourceShapeImpl(config, context);
+  const result = checkBackendSourceShapeImpl(config, context);
+  const roots = absoluteRoots(config.root, [...config.backend.features, ...config.backend.modules]);
+  const localFiles = new Set(context.files.map(file => canonical(file.fileName)));
+  const frameworkByChecker = new Map();
+  const namingReasons = [];
+  // The shared shape walk dispatches Query and Mutation; subscriptions use the same naming relation here.
+  for (const sourceFile of context.files) {
+    const fileName = canonical(sourceFile.fileName);
+    const configuredRoot = locatedRoot(roots, fileName);
+    const owner = config.hfs?.ownerOf?.(relativePath(config.root, fileName));
+    const slot = owner ? config.hfs.slot(owner.slot) : null;
+    if (!configuredRoot && !(slot?.tier === 'feature' && slot.profiles?.includes('be'))) continue;
+    const checker = context.checkerFor(fileName);
+    if (!frameworkByChecker.has(checker)) frameworkByChecker.set(checker, frameworkTargets(config, context, checker, localFiles));
+    const framework = frameworkByChecker.get(checker);
+    inspectSubscriptionSource({ config, context, sourceFile, checker, framework, configuredRoot, namingReasons, violations: result.violations });
+  }
+  if (namingReasons.length) result.coverage.naming = {
+    status: 'unavailable', reason: 'one or more backend source naming relations are not statically proved',
+    details: [...new Set([...(result.coverage.naming.details ?? []), ...namingReasons])].sort(byCodeUnit),
+  };
+  return result;
 }
 export { SOURCE_LAYOUT_RULE_ID, SOURCE_NAME_RULE_ID };