@starci/eslint-canon-fe 9.9.3 → 9.9.5

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 9.9.5 - 2026-11-02
+
+- Changed: synchronized the canonical function-provenance runtime and HFS 5.0.1 cohort pins; the Grammar component runtime stays at 0.21.3.
+
+## 9.9.4 - 2026-11-02
+
+- Changed: refreshed bundled canonical pins for the HFS 5.0.0 project quality-gate cohort; the Grammar component runtime stays at 0.21.3.
+
 ## 9.9.3 - 2026-11-02
 
 - Changed: bundled canonical pins follow the consolidated Grammar 0.21.3 preservation API cohort; runtime rules are unchanged.

package/dist/lib/slot-read-origin.d.ts

@@ -0,0 +1,6 @@
+import type { TSESTree } from "@typescript-eslint/utils";
+import type { AnyContext, Node } from "./rule.js";
+/** A memo is a projection, not a read: trace data accesses inside it back to their hook-result bindings. */
+export declare const projectedReads: (context: AnyContext, root: TSESTree.Identifier) => readonly TSESTree.Identifier[] | null;
+/** Every underlying read is folded and the returned projector actually consumes this fallback expression. */
+export declare const slotProtectsFold: (context: AnyContext, fold: TSESTree.LogicalExpression, fn: Node) => boolean;

package/dist/lib/slot-read-origin.js

@@ -0,0 +1,203 @@
+/** R367: prove that a returned canonical slot consumes the folded data and the reads that produced it. */
+import path from "node:path";
+import ts from "typescript";
+import { importOf, unwrap, variableOf } from "./bindings.js";
+const initializer = (context, node) => {
+    const definition = variableOf(context, node)?.defs.find(entry => entry.type === "Variable" && entry.parent?.kind === "const");
+    return definition?.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" ? definition.node.init : null;
+};
+/** Property names and object keys do not read an identically named variable. */
+const reference = (node) => !(node.parent.type === "MemberExpression" && node.parent.property === node && !node.parent.computed)
+    && !(node.parent.type === "Property" && node.parent.key === node && !node.parent.computed && !node.parent.shorthand);
+const visits = (context, root, visit) => {
+    visit(root);
+    for (const key of context.sourceCode.visitorKeys[root.type] ?? []) {
+        const value = Reflect.get(root, key);
+        const children = Array.isArray(value) ? value : [value];
+        for (const child of children)
+            if (child !== null && typeof child === "object" && "type" in child)
+                visits(context, child, visit);
+    }
+};
+/** Follow const aliases by lexical binding; a similarly named variable in another callback is unrelated. */
+const dependsOn = (context, input, target, seen = new Set()) => {
+    if (input === target)
+        return true;
+    if (seen.has(input))
+        return false;
+    seen.add(input);
+    let found = false;
+    visits(context, input, node => {
+        if (node === target)
+            found = true;
+        if (node.type !== "Identifier" || !reference(node))
+            return;
+        const value = initializer(context, node);
+        if (value && dependsOn(context, value, target, seen))
+            found = true;
+    });
+    return found;
+};
+const access = (input, computed = false) => {
+    const keys = [];
+    let node = unwrap(input);
+    while (node.type === "MemberExpression" || node.type === "CallExpression") {
+        if (node.type === "CallExpression") {
+            node = unwrap(node.callee);
+            continue;
+        }
+        const key = !node.computed && node.property.type === "Identifier" ? node.property.name : node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
+        if (key === null && !computed)
+            return null;
+        keys.unshift(key ?? "*");
+        node = unwrap(node.object);
+    }
+    return node.type === "Identifier" ? { root: node, keys } : null;
+};
+const sameAccess = (context, input, root, keys) => {
+    const candidate = access(input);
+    return candidate !== null && variableOf(context, candidate.root) === variableOf(context, root)
+        && candidate.keys.length === keys.length && candidate.keys.every((key, index) => key === keys[index]);
+};
+const canonicalFold = (context, node) => {
+    const callee = unwrap(node.callee);
+    if (callee.type !== "Identifier")
+        return false;
+    const imported = importOf(context, callee);
+    if (imported?.imported !== "slotOfReads")
+        return false;
+    const source = imported.source.startsWith(".") ? path.resolve(path.dirname(context.filename), imported.source).replaceAll("\\", "/") : imported.source;
+    return /(?:^|\/)hooks\/slot(?:\/index)?(?:\.[cm]?ts)?$/.test(source);
+};
+const ownFunction = (node) => {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression")
+            return parent;
+    }
+    return null;
+};
+/** A memo is a projection, not a read: trace data accesses inside it back to their hook-result bindings. */
+export const projectedReads = (context, root) => {
+    const call = unwrap(initializer(context, root));
+    if (call?.type !== "CallExpression")
+        return null;
+    const callee = unwrap(call.callee);
+    const imported = callee.type === "Identifier" ? importOf(context, callee) : null;
+    if (imported?.source !== "react" || imported.imported !== "useMemo")
+        return null;
+    const roots = [];
+    visits(context, call, node => {
+        if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier" || node.property.name !== "data")
+            return;
+        const owner = access(node.object);
+        if (!owner)
+            return;
+        const origin = unwrap(initializer(context, owner.root));
+        if (origin?.type === "CallExpression" && origin.callee.type === "Identifier" && /^use[A-Z]/.test(origin.callee.name)
+            && !roots.some(known => variableOf(context, known) === variableOf(context, owner.root)))
+            roots.push(owner.root);
+    });
+    return roots;
+};
+const readArray = (context, input, seen = new Set()) => {
+    const node = unwrap(input);
+    if (!node || seen.has(node))
+        return null;
+    seen.add(node);
+    if (node.type === "Identifier")
+        return readArray(context, initializer(context, node) ?? undefined, seen);
+    return node.type === "ArrayExpression" && node.elements.every(element => element !== null && element.type !== "SpreadElement") ? node.elements : null;
+};
+/** A composite hook's returned data is traced to its own read declarations, then back to its public read paths. */
+const compositeReads = (context, root, output) => {
+    const definition = variableOf(context, root)?.defs.find(entry => entry.type === "Variable");
+    const call = definition?.node.type === "VariableDeclarator" ? unwrap(definition.node.init) : null;
+    const services = context.sourceCode.parserServices;
+    const checker = services?.program?.getTypeChecker();
+    const mapped = call && services?.esTreeNodeToTSNodeMap?.get(call);
+    if (!checker || !mapped || !ts.isCallExpression(mapped))
+        return null;
+    const declaration = checker.getResolvedSignature(mapped)?.declaration;
+    if (!declaration || !(ts.isArrowFunction(declaration) || ts.isFunctionDeclaration(declaration) || ts.isFunctionExpression(declaration)) || !declaration.body)
+        return null;
+    const returned = ts.isBlock(declaration.body) ? declaration.body.statements.filter(ts.isReturnStatement) : [];
+    const value = ts.isBlock(declaration.body) ? returned.length === 1 ? returned[0]?.expression : undefined : declaration.body;
+    if (!value || !ts.isObjectLiteralExpression(value))
+        return null;
+    const expressionOf = (property) => ts.isPropertyAssignment(property) ? property.initializer : ts.isShorthandPropertyAssignment(property) ? property.name : undefined;
+    const field = value.properties.find(property => property.name && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) && property.name.text === output);
+    const data = field && expressionOf(field);
+    if (!data)
+        return null;
+    const symbolOf = (node) => ts.isShorthandPropertyAssignment(node.parent)
+        ? checker.getShorthandAssignmentValueSymbol(node.parent) : checker.getSymbolAtLocation(node);
+    const variable = (node) => symbolOf(node)?.declarations?.find(ts.isVariableDeclaration);
+    const hookRead = (node) => {
+        const init = variable(node)?.initializer;
+        return init && ts.isCallExpression(init) && ts.isIdentifier(init.expression) && /^use[A-Z]/.test(init.expression.text) ? symbolOf(node) : undefined;
+    };
+    const origins = new Set();
+    const seen = new Set();
+    const collect = (node) => {
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        if (ts.isPropertyAccessExpression(node) && node.name.text === "data" && ts.isIdentifier(node.expression)) {
+            const origin = hookRead(node.expression);
+            if (origin) {
+                origins.add(origin);
+                return;
+            }
+        }
+        if (ts.isIdentifier(node) && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node)) {
+            const init = variable(node)?.initializer;
+            if (init && init.getSourceFile() === declaration.getSourceFile())
+                collect(init);
+        }
+        ts.forEachChild(node, collect);
+    };
+    collect(data);
+    if (origins.size === 0)
+        return null;
+    const paths = new Map();
+    const exposed = (node, keys) => {
+        if (ts.isIdentifier(node)) {
+            const origin = hookRead(node);
+            if (origin)
+                paths.set(origin, keys);
+        }
+        else if (ts.isObjectLiteralExpression(node)) {
+            for (const property of node.properties) {
+                const expression = expressionOf(property);
+                if (expression && property.name && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)))
+                    exposed(expression, [...keys, property.name.text]);
+            }
+        }
+    };
+    exposed(value, []);
+    return [...origins].every(origin => paths.has(origin)) ? [...origins].map(origin => paths.get(origin)) : null;
+};
+/** Every underlying read is folded and the returned projector actually consumes this fallback expression. */
+export const slotProtectsFold = (context, fold, fn) => {
+    const source = access(fold.left, true);
+    if (!source)
+        return false;
+    const required = source.keys.length > 0 ? compositeReads(context, source.root, source.keys[0]) : null;
+    let protectedFold = false;
+    visits(context, fn, node => {
+        if (node.type !== "CallExpression" || ownFunction(node) !== fn || !canonicalFold(context, node))
+            return;
+        const reads = readArray(context, node.arguments[0]);
+        const projector = unwrap(node.arguments[1]);
+        if (!reads || !projector || projector.type !== "ArrowFunctionExpression" || !dependsOn(context, projector.body, fold))
+            return;
+        const paths = required ?? [[]];
+        if (!paths.every(keys => reads.some(read => sameAccess(context, read, source.root, keys))))
+            return;
+        visits(context, fn, candidate => {
+            if (candidate.type === "ReturnStatement" && ownFunction(candidate) === fn && candidate.argument && dependsOn(context, candidate.argument, node))
+                protectedFold = true;
+        });
+    });
+    return protectedFold;
+};

package/dist/skeleton-states.js

@@ -1,4 +1,6 @@
 import { defineRule } from "./lib/rule.js";
+import { importOf } from "./lib/bindings.js";
+import { projectedReads, slotProtectsFold } from "./lib/slot-read-origin.js";
 const pathOf = (context) => context.filename.replaceAll("\\", "/");
 /** A hook that reads data for a view: under `hooks/`, and not the SWR layer that makes the reads (`hooks/swr`). */
 const isViewHook = (context) => {
@@ -48,7 +50,10 @@ const isHookResult = (context, node, identifier) => {
                 return false;
             const init = unwrap(declarator.init);
             const callee = init?.type === "CallExpression" ? unwrap(init.callee) : null;
-            const name = callee?.type === "Identifier" ? callee.name : callee?.type === "MemberExpression" && callee.property.type === "Identifier" ? callee.property.name : null;
+            const imported = callee?.type === "Identifier" ? importOf(context, callee) : callee?.type === "MemberExpression" && callee.object.type === "Identifier" ? importOf(context, callee.object) : null;
+            if (imported?.source === "react" && imported.imported !== "useMemo")
+                return false;
+            const name = imported?.source === "react" ? imported.imported : callee?.type === "Identifier" ? callee.name : callee?.type === "MemberExpression" && callee.property.type === "Identifier" ? callee.property.name : null;
             return name !== null && /^use[A-Z]/.test(name);
         });
     }
@@ -78,12 +83,17 @@ const noSwrDefaultArray = defineRule({
                 if (!fn)
                     return;
                 const text = source.getText(fn);
-                const escaped = root.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const projections = projectedReads(context, root);
+                if (projections?.length === 0)
+                    return;
                 // The read's own status is read in the same hook: `read.isLoading`, or destructured next to `data`.
-                const readsStatus = new RegExp(`\\b${escaped}\\??\\.(?:isLoading|error|isError)\\b`).test(text)
-                    || new RegExp(`\\{[^}]*\\b(?:isLoading|error)\\b[^}]*\\}\\s*=\\s*${escaped}\\b`).test(text)
-                    || (root.name === "data" && /\bisLoading\b/.test(text));
-                if (readsStatus)
+                const readsStatus = (projections ?? [root]).every(read => {
+                    const escaped = read.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                    return new RegExp(`\\b${escaped}\\??\\.(?:isLoading|error|isError)\\b`).test(text)
+                        || new RegExp(`\\{[^}]*\\b(?:isLoading|error)\\b[^}]*\\}\\s*=\\s*${escaped}\\b`).test(text)
+                        || (read.name === "data" && /\bisLoading\b/.test(text));
+                });
+                if (readsStatus || slotProtectsFold(context, node, fn))
                     return;
                 context.report({ node, messageId: "fold", data: { read: source.getText(node.left).slice(0, 40) } });
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-canon-fe",
-  "version": "9.9.3",
+  "version": "9.9.5",
   "description": "Universal front-end lint laws for TypeScript and Next.js, independent of the selected Grammar family.",
   "type": "module",
   "license": "MIT",

package/runtime/knowledge/hfs/canon-pins.yaml

@@ -38,28 +38,28 @@ pins:
     source: packages/grammar/package.json
     why: 'the grammar front ends read: the brand layer sets `--font-sans` and `--font-mono` and the grammar reads them; it carries the Input tel kind, the copyable and read-only Input, the IconButton disclosure props and count badge, ChatBubble, FillViewport, Textarea mentions and Enter-to-send, the leading PrimaryRailLayout rail, the plate-less Image, ListRow, the soft Alert, Progress steps, the floating primary IconButton, FlowGraph, the STATE-8 loading views and the bordered selectable TagGroup chips. The runtime source version wins for a @starci package.'
   '@starci/eslint-canon-be':
-    version: 3.11.10
+    version: 3.11.12
     group: starci
     install: registry
     side: be
     source: packages/eslint-canon-be/package.json
     why: 'the back-end ESLint canon: `loadHfs(import.meta.url)` of be/eslint.config.mjs finds the app-root hfs.json (kind app) and gives every linted file the view of the be side, and the project graph is built per side; its bundled runtime copies (slots, canon-pins, failure codes, the architecture machine) put .starcistacks and .sops.yaml at the app root; `starciBeConfig({ hfs: loadHfs(import.meta.url) })` is the typed factory and the BE-CONVENTION laws are its rules.'
   '@starci/eslint-canon-fe':
-    version: 9.9.3
+    version: 9.9.5
     group: starci
     install: registry
     side: fe
     source: packages/eslint-canon-fe/package.json
     why: 'the front-end ESLint canon: `loadHfs(import.meta.url)` of fe/eslint.config.mjs finds the app-root hfs.json (kind app) and gives every linted file the view of the fe side, and the project graph is built per side; its bundled runtime copies (slots, canon-pins, failure codes, the architecture machine) put .starcistacks and .sops.yaml at the app root; the front end has no tests (FE_NO_TESTS R97 in hfs) and no-vietnamese-in-source (R91) applies.'
   '@starci/eslint-grammar-core':
-    version: 0.21.3
+    version: 0.21.5
     group: starci
     install: registry
     side: fe
     source: packages/eslint-grammar-core/package.json
     why: 'the StarCi Grammar component API lint, versioned with @starci/grammar; front ends compose this family package with the universal FE canon.'
   '@starci/eslint-grammar-offset-pop':
-    version: 0.21.3
+    version: 0.21.5
     group: starci
     install: registry
     side: fe
@@ -106,7 +106,7 @@ pins:
     source: packages/ai-router/package.json
     why: 'the AI pool router of a back end: a NestJS module that routes OpenAI-compatible chat, stream and embeddings calls across keys, models and providers, with @starci/ai-router/testing for its specs; @starci/jest-preset compiles it as an ESM-only dependency.'
   '@starci/hfs':
-    version: 4.17.3
+    version: 5.0.1
     group: starci
     install: registry
     side: both

package/runtime/scripts/hfs/architecture/canon-jsx-clones.mjs

@@ -17,7 +17,7 @@ function importBindings(ts, scope, statement) {
         return;
     const module = statement.moduleSpecifier.text;
     if (clause.name)
-        scope.bindings.set(clause.name.text, { kind: 'component' });
+        scope.bindings.set(clause.name.text, { kind: 'component', module, name: 'default' });
     const named = clause.namedBindings;
     if (!named)
         return;
@@ -28,8 +28,9 @@ function importBindings(ts, scope, statement) {
             if (element.isTypeOnly)
                 continue;
             const imported = element.propertyName?.text ?? element.name.text;
-            const kind = TRANSLATION_MODULES.has(module) && TRANSLATION_FACTORIES.has(imported) ? 'translation-factory' : 'component';
-            scope.bindings.set(element.name.text, { kind });
+            const binding = TRANSLATION_MODULES.has(module) && TRANSLATION_FACTORIES.has(imported)
+                ? { kind: 'translation-factory' } : { kind: 'component', module, name: imported };
+            scope.bindings.set(element.name.text, binding);
         }
 }
 function lexicalBindings(ts, sourceFile) {
@@ -151,12 +152,55 @@ function nestedDataObjects(ts, expression, bindingOf, excluded) {
                 nestedDataObjects(ts, element, bindingOf, excluded);
     }
 }
+/** Resolve the canonical status owner through its import binding, including aliases and namespaces. */
+function statusOwner(ts, tag, bindingOf) {
+    const binding = ts.isIdentifier(tag) ? bindingOf(tag) : ts.isPropertyAccessExpression(tag) && ts.isIdentifier(tag.expression) ? bindingOf(tag.expression) : null;
+    const module = binding?.kind === 'component' || binding?.kind === 'namespace' ? binding.module : null;
+    const name = binding?.kind === 'component' ? binding.name : ts.isPropertyAccessExpression(tag) ? tag.name.text : null;
+    return name === 'SlotView' && module !== null && /(?:^|\/)components\/composites\/SlotView(?:\/index)?(?:\.[cm]?tsx?)?$/.test(module);
+}
+/** The mandated status wiring breaks clone windows; its render body remains ordinary compared code. */
+function statusRecipe(ts, opening, bindingOf, excluded) {
+    if (!statusOwner(ts, opening.tagName, bindingOf))
+        return;
+    const attributes = opening.attributes.properties;
+    const render = attributes.find(attribute => ts.isJsxAttribute(attribute) && ts.isIdentifier(attribute.name) && attribute.name.text === 'render');
+    const value = render && ts.isJsxAttribute(render) && render.initializer && ts.isJsxExpression(render.initializer) ? unwrap(ts, render.initializer.expression) : undefined;
+    if (!value || !ts.isArrowFunction(value) || value.parameters.length !== 2 || ts.isBlock(value.body))
+        return;
+    const waiting = value.parameters[1];
+    if (!waiting || !ts.isIdentifier(waiting.name) || waiting.initializer || waiting.dotDotDotToken)
+        return;
+    const waitingBinding = bindingOf(waiting.name);
+    let forwardsLoading = false;
+    const visit = (node) => {
+        if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && node.name.text === 'isLoading'
+            && node.initializer && ts.isJsxExpression(node.initializer)) {
+            const flag = unwrap(ts, node.initializer.expression);
+            if (flag && ts.isIdentifier(flag) && waitingBinding && bindingOf(flag) === waitingBinding)
+                forwardsLoading = true;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(value.body);
+    if (!forwardsLoading)
+        return;
+    const wiring = attributes.filter(attribute => ts.isJsxSpreadAttribute(attribute) ? dataMapping(ts, attribute.expression, bindingOf)
+        : ts.isIdentifier(attribute.name) && ['slot', 'placeholder', 'labels', 'onRetry'].includes(attribute.name.text)
+            && !!attribute.initializer && ts.isJsxExpression(attribute.initializer) && dataMapping(ts, attribute.initializer.expression, bindingOf));
+    const hasSlot = wiring.some(attribute => ts.isJsxSpreadAttribute(attribute) || ts.isJsxAttribute(attribute) && ts.isIdentifier(attribute.name) && attribute.name.text === 'slot');
+    if (!hasSlot)
+        return;
+    for (const attribute of wiring)
+        excluded.add(attribute);
+}
 /** Canon data prop objects qualify through an imported component binding, never its chosen name or file path. */
 export function canonJsxCloneNodes(ts, sourceFile) {
     const bindingOf = lexicalBindings(ts, sourceFile);
     const excluded = new Set();
     const visit = (node) => {
         if ((ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) && importedComponent(ts, node.tagName, bindingOf)) {
+            statusRecipe(ts, node, bindingOf, excluded);
             for (const attribute of node.attributes.properties) {
                 if (!ts.isJsxAttribute(attribute) || !attribute.initializer || !ts.isJsxExpression(attribute.initializer))
                     continue;

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

@@ -203,6 +203,9 @@ function signatureParameterStatus(ts, checker, signature, location, parameter, s
     const actual = parameterSymbol ? checker.getTypeOfSymbolAtLocation(parameterSymbol, location) : null;
     if (actual && parameter.questionToken && !ts.isUnionTypeNode(parameter.type) && hasAnyFlag(actual.flags, ts.TypeFlags.Union)) {
         const selected = actual.types.filter((type) => !hasAnyFlag(type.flags, ts.TypeFlags.Undefined));
+        // An optional boolean is represented as true | false | undefined, not one Boolean member.
+        if (selected.length > 0 && selected.every((type) => hasAnyFlag(type.flags, ts.TypeFlags.BooleanLike)))
+            return 'scalar';
         return selected.length === 1 ? contractTypeStatusFromType(ts, checker, selected[0]) : 'inline';
     }
     return actual ? contractTypeStatusFromType(ts, checker, actual) : contractTypeStatus(ts, checker, parameter.type);

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

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { normalizedSymbol } from './ast-walks.mjs';
 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. */
@@ -19,17 +20,30 @@ function callableExports(ts, statement) {
         return statement.name && statement.body ? [statement.name.text] : [];
     return ts.isVariableStatement(statement) ? callableVariables(ts, statement) : [];
 }
+/** Named value re-exports count only when the checker resolves an actual function implementation. */
+function callableReexports(ts, checker, statement) {
+    if (!ts.isExportDeclaration(statement) || statement.isTypeOnly || !statement.exportClause || !ts.isNamedExports(statement.exportClause))
+        return [];
+    return statement.exportClause.elements.filter(element => !element.isTypeOnly && (normalizedSymbol(ts, checker, element.name)?.declarations ?? []).some(declaration => {
+        if (declaration.getSourceFile().isDeclarationFile)
+            return false;
+        if (ts.isFunctionDeclaration(declaration))
+            return Boolean(declaration.body);
+        return ts.isVariableDeclaration(declaration) && Boolean(declaration.initializer
+            && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)));
+    })).map(element => element.name.text);
+}
 /**
- * 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.
+ * The callable subset of a function subject's exports, including named re-exports resolved to real implementations. Constants,
+ * enums, objects, type-only exports and bodyless declarations do not count; 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) {
+export function functionSubjectExports(ts, sourceFile, checker) {
     const names = [];
     for (const statement of sourceFile.statements) {
         if (ts.isClassDeclaration(statement) || ts.isExportAssignment(statement))
             return null;
-        for (const name of callableExports(ts, statement))
+        for (const name of [...callableExports(ts, statement), ...callableReexports(ts, checker, statement)])
             if (!names.includes(name))
                 names.push(name);
     }

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

@@ -18,7 +18,7 @@ import { checkFunctionSubject, functionSubjectExports, keyOf as literalKey, valu
  * constructor-deps.mjs). Providers are matched by the exported name of the imported binding (`import { CACHE as C }` is
  * CACHE), never by text. A provider is a class, or `{ provide: TOKEN, useValue: double }` and nothing else. A sibling
  * containing only exported functions instead provides its complete real function object and exercises it through module.get;
- * the constants, enums, re-exports and overload signatures beside those functions do not count. A value-object subject (an
+ * callable named re-exports count, while constants, enums, type-only exports and overload signatures do not. A value-object subject (an
  * undecorated class whose constructor parameters carry no injection token) is built with `new`, Nest never constructs it.
  *
  * Findings: an extra provider, a missing provider, a service that is not the first provider, a dependency whose token cannot
@@ -111,7 +111,7 @@ function checkTestingModule({ ts, kit, rel, serviceRel, serviceFile, imports, ca
     const list = providerList(ts, call, rel, report);
     if (!list)
         return;
-    const names = functionSubjectExports(ts, serviceFile.sourceFile);
+    const names = functionSubjectExports(ts, serviceFile.sourceFile, kit.checkerOf(serviceFile.sourceFile));
     if (names) {
         checkFunctionSubject({ ts, rel, serviceRel, imports, call, list, names, report });
         return;