@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/dist/src/bindings.js

@@ -0,0 +1,382 @@
+/**
+ * The binding identities of the facts document, `bindings.6` and `bindings.7`: the consumer
+ * records a generator row's output names, read from the syntax its plugin writes, and the
+ * fallback records of the rows that bind a file only as a whole. The run publishes no state,
+ * so every record is an identity (`bindings.10`).
+ */
+import { isAsExpression, isEnumDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isJSDocText, isLiteralTypeNode, isMethodSignatureDeclaration, isObjectLiteralExpression, isParenthesizedTypeNode, isPropertyAssignment, isPropertySignatureDeclaration, isSatisfiesExpression, isStringLiteralLikeNode, isTypeAliasDeclaration, isTypeLiteralNode, isTypeReferenceNode, isUnionTypeNode, isVariableStatement, } from "@typescript/native/ast";
+import { GENERATORS } from "./contract/contract.generated.js";
+import { componentOf, nameNodeOf } from "./inventory.js";
+import { nameComponent, spell } from "./ref.js";
+import { bytewise } from "./text/compare.js";
+/** The `@generated from <kind> <rest>` tags of one node's own documentation, in order. */
+function generatedTags(node) {
+    const docs = node.jsDoc ?? [];
+    return docs.flatMap((doc) => (doc.tags ?? []).flatMap((tag) => {
+        const { tagName, comment } = tag;
+        if (tagName === undefined || !isIdentifier(tagName) || tagName.text !== "generated") {
+            return [];
+        }
+        const text = (comment ?? [])
+            .map((part) => (isJSDocText(part) ? part.text : ""))
+            .join("")
+            .trim();
+        const found = /^from (\w+(?: value)?):? (.+)$/u.exec(text);
+        return found === null ? [] : [{ kind: found[1] ?? "", rest: (found[2] ?? "").trim() }];
+    }));
+}
+/** The tag of one kind a node carries, its text after the kind. */
+function tagged(node, kind) {
+    return generatedTags(node).find((one) => one.kind === kind)?.rest;
+}
+/**
+ * The name a field or an enum value tag declares: the word before ` = <number>`, read
+ * before an optional bracketed option list (`= 7 [json_name = "sync"];`).
+ */
+function declaredName(rest) {
+    return /(\w+) = \d+(?: \[.*\])?;$/u.exec(rest)?.[1];
+}
+/** The spelled component of one declaration's name, or undefined for a name the grammar cannot spell. */
+function spelledName(node) {
+    const component = componentOf(nameNodeOf(node));
+    return component === undefined ? undefined : spell(component);
+}
+/** The object type literals one type is or holds as a direct constituent of a union or an intersection. */
+function literalsOf(type) {
+    if (type === undefined) {
+        return [];
+    }
+    if (isParenthesizedTypeNode(type)) {
+        return literalsOf(type.type);
+    }
+    if (isUnionTypeNode(type) || isIntersectionTypeNode(type)) {
+        return type.types.flatMap((one) => literalsOf(one));
+    }
+    return isTypeLiteralNode(type) ? [type] : [];
+}
+/** The string literal type one type literal declares for its `case` property, the oneof discriminant. */
+function caseOf(literal) {
+    if (!isTypeLiteralNode(literal)) {
+        return undefined;
+    }
+    for (const member of literal.members) {
+        if (isPropertySignatureDeclaration(member) &&
+            spelledName(member) === "case" &&
+            isLiteralTypeNode(member.type) &&
+            isStringLiteralLikeNode(member.type.literal)) {
+            return member.type.literal.text;
+        }
+    }
+    return undefined;
+}
+/** The fields, enum values and oneof constituents of one tagged message or enum, below its fragment. */
+function membersOf(members, fragment, name) {
+    return members.flatMap((member) => {
+        const spelled = spelledName(member);
+        if (spelled === undefined) {
+            return [];
+        }
+        const at = `${fragment}.${spelled}`;
+        const field = tagged(member, "field") ?? tagged(member, "enum value");
+        const declared = field === undefined ? undefined : declaredName(field);
+        if (declared !== undefined) {
+            return [{ fragment: at, name: `${name}.${declared}` }];
+        }
+        if (tagged(member, "oneof") === undefined || !isPropertySignatureDeclaration(member)) {
+            return [];
+        }
+        return literalsOf(member.type).flatMap((constituent) => {
+            const discriminant = caseOf(constituent);
+            return discriminant === undefined
+                ? []
+                : [
+                    {
+                        fragment: `${at}.'${discriminant.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}':case`,
+                        name: `${name}.${discriminant}`,
+                    },
+                ];
+        });
+    });
+}
+/** The full name `@generated from <kind> <pkg.Name>` gives, without a trailing comment. */
+function fullName(rest) {
+    return rest.split(/\s/u)[0] ?? rest;
+}
+/** The consumers a protoc-gen-es file of row `protoc-gen-es-2` names, as `references-ts.28` reads them. */
+function protobufEsConsumers(file) {
+    const found = [];
+    const typed = new Map();
+    const constants = [];
+    for (const statement of file.statements) {
+        if (isTypeAliasDeclaration(statement) || isInterfaceDeclaration(statement)) {
+            const fragment = spelledName(statement);
+            const message = tagged(statement, "message");
+            if (fragment === undefined || message === undefined) {
+                continue;
+            }
+            const name = fullName(message);
+            typed.set(statement.name.text, name);
+            found.push({ fragment, name });
+            const members = isInterfaceDeclaration(statement)
+                ? statement.members
+                : literalsOf(statement.type).flatMap((one) => (isTypeLiteralNode(one) ? one.members : []));
+            found.push(...membersOf(members, fragment, name));
+        }
+        else if (isEnumDeclaration(statement)) {
+            const fragment = spelledName(statement);
+            const enumName = tagged(statement, "enum");
+            if (fragment === undefined || enumName === undefined) {
+                continue;
+            }
+            const name = fullName(enumName);
+            typed.set(statement.name.text, name);
+            found.push({ fragment, name }, ...membersOf(statement.members, fragment, name));
+        }
+        else if (isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const fragment = spelledName(declaration);
+                if (fragment === undefined) {
+                    continue;
+                }
+                const tags = [...generatedTags(statement), ...generatedTags(declaration)];
+                const enumName = tags.find((one) => one.kind === "enum")?.rest;
+                const service = tags.find((one) => one.kind === "service")?.rest;
+                const initializer = declaration.initializer;
+                const object = initializer === undefined ? undefined : asConst(initializer);
+                if (enumName !== undefined && object !== undefined && isObjectLiteralExpression(object)) {
+                    const name = fullName(enumName);
+                    typed.set(fragment, name);
+                    found.push({ fragment, name }, ...membersOf(object.properties, fragment, name));
+                }
+                else if (service !== undefined) {
+                    found.push({ fragment, name: fullName(service) });
+                    const [methods] = typeArguments(declaration.type);
+                    for (const literal of literalsOf(methods)) {
+                        for (const member of isTypeLiteralNode(literal) ? literal.members : []) {
+                            const spelled = spelledName(member);
+                            const rpc = tagged(member, "rpc");
+                            if (spelled !== undefined && rpc !== undefined) {
+                                found.push({ fragment: `${fragment}.${spelled}`, name: fullName(rpc) });
+                            }
+                        }
+                    }
+                }
+                else if (declaration.type !== undefined) {
+                    constants.push({ fragment, type: declaration.type, node: declaration });
+                }
+            }
+        }
+    }
+    for (const constant of constants) {
+        const type = constant.type;
+        if (!isTypeReferenceNode(type) || !isIdentifier(type.typeName)) {
+            continue;
+        }
+        if (type.typeName.text !== "GenMessage" && type.typeName.text !== "GenEnum") {
+            continue;
+        }
+        const [argument] = typeArguments(type);
+        const named = argument !== undefined && isTypeReferenceNode(argument) && isIdentifier(argument.typeName)
+            ? typed.get(argument.typeName.text)
+            : undefined;
+        if (named !== undefined) {
+            found.push({ fragment: constant.fragment, name: named });
+        }
+    }
+    return found;
+}
+/** The expression an `as const` or `satisfies` clause holds, or the expression itself. */
+function asConst(node) {
+    return isAsExpression(node) || isSatisfiesExpression(node) ? asConst(node.expression) : node;
+}
+/** The type arguments one type reference writes. */
+function typeArguments(type) {
+    return type !== undefined && isTypeReferenceNode(type) ? (type.typeArguments ?? []) : [];
+}
+/** A ts-proto service path literal, split into its service and its method. */
+const SERVICE_PATH = /^\/((?:\w+\.)*\w+)\/(\w+)$/u;
+/**
+ * The service and RPC consumers a ts-proto file of row `ts-proto-2` names, as
+ * `references-ts.31` reads them: the methods of the interface a `<Svc>ServiceName`
+ * constant names, and a definition object whose members write a service `path`, with each
+ * member the consumer of its RPC and the object, and the `<Svc>Client` that the same
+ * file declares beside it, consumers of the service.
+ */
+function tsProtoConsumers(file) {
+    const found = [];
+    const interfaces = new Map();
+    const clients = new Set();
+    for (const statement of file.statements) {
+        if (isInterfaceDeclaration(statement)) {
+            interfaces.set(statement.name.text, statement.members);
+        }
+        if (isVariableStatement(statement)) {
+            for (const one of statement.declarationList.declarations) {
+                if (isIdentifier(one.name)) {
+                    clients.add(one.name.text);
+                }
+            }
+        }
+    }
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const { name, initializer } = declaration;
+            if (!isIdentifier(name) || initializer === undefined) {
+                continue;
+            }
+            if (name.text.endsWith("ServiceName") && isStringLiteralLikeNode(initializer)) {
+                const service = name.text.slice(0, -"ServiceName".length);
+                for (const member of interfaces.get(service) ?? []) {
+                    const spelled = spelledName(member);
+                    if (spelled !== undefined && isMethodSignatureDeclaration(member)) {
+                        found.push({
+                            fragment: `${nameComponent(service)}.${spelled}`,
+                            name: `${initializer.text}.${spelled}`,
+                        });
+                    }
+                }
+                continue;
+            }
+            const object = asConst(initializer);
+            if (!isObjectLiteralExpression(object)) {
+                continue;
+            }
+            let service;
+            for (const property of object.properties) {
+                const spelled = spelledName(property);
+                const value = isPropertyAssignment(property) ? asConst(property.initializer) : undefined;
+                const path = value !== undefined && isObjectLiteralExpression(value)
+                    ? value.properties.find((one) => isPropertyAssignment(one) &&
+                        spelledName(one) === "path" &&
+                        isStringLiteralLikeNode(one.initializer))
+                    : undefined;
+                const matched = path !== undefined &&
+                    isPropertyAssignment(path) &&
+                    isStringLiteralLikeNode(path.initializer)
+                    ? SERVICE_PATH.exec(path.initializer.text)
+                    : null;
+                if (spelled === undefined || matched === null) {
+                    continue;
+                }
+                service = matched[1];
+                const rpc = `${matched[1] ?? ""}.${matched[2] ?? ""}`;
+                found.push({ fragment: `${nameComponent(name.text)}.${spelled}`, name: rpc });
+                const client = `${name.text.replace(/Service$/u, "")}Client`;
+                if (interfaces.get(client)?.some((member) => spelledName(member) === spelled) === true) {
+                    found.push({ fragment: `${nameComponent(client)}.${spelled}`, name: rpc });
+                }
+            }
+            if (service !== undefined) {
+                found.push({ fragment: nameComponent(name.text), name: service });
+                const client = `${name.text.replace(/Service$/u, "")}Client`;
+                if (interfaces.has(client) || clients.has(client)) {
+                    found.push({ fragment: nameComponent(client), name: service });
+                }
+            }
+        }
+    }
+    return found;
+}
+/** The package `// @generated from file <path> (package <pkg>, ...)` or `protobufPackage` names, `.` for none. */
+function packageOf(file) {
+    const header = /^\/\/ @generated from file \S+ \(package ([\w.]+)/mu.exec(file.text)?.[1];
+    if (header !== undefined) {
+        return header;
+    }
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const one of statement.declarationList.declarations) {
+            if (isIdentifier(one.name) &&
+                one.name.text === "protobufPackage" &&
+                one.initializer !== undefined &&
+                isStringLiteralLikeNode(one.initializer) &&
+                one.initializer.text !== "") {
+                return one.initializer.text;
+            }
+        }
+    }
+    return ".";
+}
+/** The `proto://` reference of a schema declaration a full name written in package `pkg` names. */
+function schemaRef(pkg, name) {
+    const local = pkg !== "." && name.startsWith(`${pkg}.`) ? name.slice(pkg.length + 1) : name;
+    return `proto://${pkg}#${local}`;
+}
+/** The consumer reader of each row whose output the analyzer decodes. */
+const CONSUMERS = {
+    "protoc-gen-es-2": protobufEsConsumers,
+    "ts-proto-2": tsProtoConsumers,
+};
+/** The scope of the fallback record each fallback cell publishes. */
+const FALLBACK_SCOPE = {
+    fallback: "all",
+    "rpc-types-fallback": "types",
+};
+/**
+ * The binding records one project's generated files publish, each file read once:
+ * `files` by path below the target root, `moduleRefs` each file's own reference.
+ */
+export function bindingsOf(files, generated, moduleRefs) {
+    const records = [];
+    for (const [path, fact] of generated) {
+        const file = files.get(path);
+        const moduleRef = moduleRefs.get(path);
+        const generator = fact.generator;
+        if (file === undefined || moduleRef === undefined || generator === undefined) {
+            continue;
+        }
+        const [schemaFile] = generator.schemaFiles;
+        const cell = GENERATORS.find((row) => row.id === generator.row)?.cell;
+        const scope = cell === undefined ? undefined : FALLBACK_SCOPE[cell];
+        if (scope !== undefined) {
+            for (const one of generator.schemaFiles) {
+                records.push({
+                    role: "fallback",
+                    symbol: moduleRef,
+                    schema_file: one,
+                    generated_file: path,
+                    scope,
+                    state: "live",
+                });
+            }
+        }
+        const read = CONSUMERS[generator.row];
+        if (read === undefined || schemaFile === undefined) {
+            continue;
+        }
+        const pkg = packageOf(file);
+        const seen = new Set();
+        for (const named of read(file)) {
+            const symbol = `${moduleRef}${named.fragment}`;
+            if (seen.has(symbol)) {
+                continue;
+            }
+            seen.add(symbol);
+            records.push({
+                role: "consumer",
+                symbol,
+                schema_file: schemaFile,
+                schema: schemaRef(pkg, named.name),
+                generated_file: path,
+            });
+        }
+    }
+    return records;
+}
+/**
+ * The records of a run's projects, each once, in the order the facts schema states: by
+ * schema file, schema, role and symbol. A generated file two projects hold publishes its
+ * records in each.
+ */
+export function distinctBindings(records) {
+    const byKey = new Map(records.map((one) => [JSON.stringify(one), one]));
+    return [...byKey.values()].sort((a, b) => bytewise(a.schema_file, b.schema_file) ||
+        bytewise(a.schema ?? "", b.schema ?? "") ||
+        bytewise(a.role, b.role) ||
+        bytewise(a.symbol, b.symbol));
+}

package/dist/src/calls.js

@@ -2,13 +2,14 @@
  * The calls and decorators of one project that the configured classes read: what each
  * callee resolves to, and which of the target's classes a call passes or a decorator
  * is attached to. A class is passed as an argument, or as an element of an array
- * literal or a property value of an object literal written as one, at any depth, and a
- * decorator written as a call is a call.
+ * literal or a property value of an object literal written as one, at any depth, named
+ * directly or through variables, and a decorator written as a call is a call.
  */
-import { isArrayLiteralExpression, isCallExpression, isClassDeclaration, isDecorator, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isCallExpression, isClassDeclaration, isDecorator, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isVariableDeclaration, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { nodeKey } from "./inventory.js";
 import { must } from "./query.js";
+import { unwrapped } from "./unwrap.js";
 /** The name node a callee or a decorator expression resolves through, where it has one. */
 export function calleeName(expression) {
     if (isParenthesizedExpression(expression)) {
@@ -100,21 +101,37 @@ export function valuesPassed(argument) {
     return found;
 }
 /**
- * The classes of the target each call passes, by the call. A value that names no
- * class of the target, a class of another program included, passes nothing here.
+ * The classes of the target each call passes, by the call. A name that is no class is
+ * followed through the initializer of each variable it declares, so a class bound to a
+ * variable first is passed. A value that names no class of the target, a class of
+ * another program included, passes nothing here.
  */
 export function classesPassed(project, held, chains, calls) {
     const passed = new Map(calls.map((call) => [call, call.arguments.flatMap((argument) => valuesPassed(argument))]));
     const all = [...passed.values()].flat();
     const targets = resolvedTargets(project, all.filter((value) => !value.shorthand).map((value) => value.name));
     const classes = new Set(held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id));
+    const reached = (symbol, seen) => {
+        const ids = chains.declarationsOf(symbol).filter((id) => classes.has(id));
+        if (ids.length > 0 || seen.has(symbol.id)) {
+            return ids;
+        }
+        seen.add(symbol.id);
+        return symbol.declarations.flatMap((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            if (node === undefined || !isVariableDeclaration(node) || node.initializer === undefined) {
+                return [];
+            }
+            const name = calleeName(unwrapped(node.initializer));
+            const next = name === undefined ? undefined : resolvedTargets(project, [name]).get(name);
+            return next === undefined ? [] : reached(next, seen);
+        });
+    };
     const classesOf = (value) => {
         const symbol = value.shorthand
             ? must(project.shorthandValueAt(project.handle(value.name)))
             : targets.get(value.name);
-        return symbol === undefined
-            ? []
-            : chains.declarationsOf(symbol).filter((id) => classes.has(id));
+        return symbol === undefined ? [] : reached(symbol, new Set());
     };
     return new Map([...passed].map(([call, values]) => [
         call,

package/dist/src/commands/read.js

@@ -1,12 +1,13 @@
 /**
  * The one reader of every command string the analysis reads. Layer 3, the holding rule
- * `roots.ts` applies through `text/named-files.ts`, reads all of the string's text whatever
- * the other two layers make of it; layer 1 parses the string and layer 2 reads each simple
- * command a tool's reader understands, and they only add the files and modules it runs.
+ * `roots/root-set.ts` applies through `text/named-files.ts`, reads all of the string's text
+ * whatever the other two layers make of it; layer 1 parses the string and layer 2 reads each
+ * simple command a tool's reader understands, and they only add the files and modules it runs.
  */
 import { joinPath, resolvePath } from "../paths.js";
 import { shellLine } from "./shell.js";
 import { configurationsOf, preloadTarget, readBuiltin, readTool, } from "./tools.js";
+import { APPENDED_EXTENSIONS } from "../extensions.js";
 /**
  * The outcomes of one pipeline run in `dir`: those of the builtin that is its one member, as
  * `readBuiltin` gives them, a directory the analysis does not know after a part layer 1 does
@@ -104,8 +105,6 @@ export function readCommands(text, dir) {
         held: text,
     };
 }
-/** The extensions a runtime or a loader tries after a path written without one. */
-const TRIED_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 /**
  * The files `run` loads: its entry, and each preload written as a path. Each may be at its
  * path, with each extension tried, and as a directory's `index` file.
@@ -126,8 +125,8 @@ export function loadsOf(run) {
         written: one,
         paths: [
             path,
-            ...TRIED_EXTENSIONS.map((extension) => `${path}${extension}`),
-            ...TRIED_EXTENSIONS.map((extension) => joinPath(path, `index${extension}`)),
+            ...APPENDED_EXTENSIONS.map((extension) => `${path}${extension}`),
+            ...APPENDED_EXTENSIONS.map((extension) => joinPath(path, `index${extension}`)),
         ],
     }));
 }

package/dist/src/commands/tools.js

@@ -5,7 +5,7 @@
  * never guesses: an option it does not handle, or a dynamic word where it needs a value, leaves
  * the command unread.
  */
-import { resolvePath } from "../paths.js";
+import { hasURLScheme, isPathSpecifier, resolvePath } from "../paths.js";
 /** The options `words` start with, or `undefined` where one is unhandled or a needed word is dynamic. */
 function optionsOf(words, options) {
     const values = new Map();
@@ -46,10 +46,6 @@ function optionsOf(words, options) {
     }
     return { values, at: words.length, ended: false };
 }
-/** A specifier that starts with a URL scheme, `file:` and `node:` among them. */
-const SCHEME = /^[a-z][a-z\d+.-]*:/iu;
-/** A specifier written as a path: `.`, `..`, or one starting `./`, `../` or `/`. */
-const RELATIVE = /^(?:\.{1,2}(?:\/|$)|\/)/u;
 /**
  * The path a URL's path text names, percent-decoded as Node's `fileURLToPath` does, with a
  * backslash read as the URL parser reads it, or `undefined` where it does not decode or
@@ -76,19 +72,19 @@ function urlPath(text) {
 export function preloadTarget(preload, dir) {
     const { specifier, resolution } = preload;
     if (resolution === "require") {
-        return RELATIVE.test(specifier)
+        return isPathSpecifier(specifier)
             ? { path: resolvePath(dir, specifier) }
-            : SCHEME.test(specifier)
+            : hasURLScheme(specifier)
                 ? undefined
                 : { package: specifier };
     }
-    if (!RELATIVE.test(specifier) && !SCHEME.test(specifier)) {
+    if (!isPathSpecifier(specifier) && !hasURLScheme(specifier)) {
         return { package: specifier };
     }
     const local = /^file:(?:\/\/(?=\/))?/iu.exec(specifier);
     const rest = specifier.slice(local?.[0].length ?? 0);
     // `file://host/…` names a file on another host.
-    if ((SCHEME.test(specifier) && local === null) || rest.startsWith("//")) {
+    if ((hasURLScheme(specifier) && local === null) || rest.startsWith("//")) {
         return undefined;
     }
     const path = urlPath(rest);

package/dist/src/component-files.js

@@ -5,6 +5,7 @@
  * of the module is the same position of the file. A default export and the imports a `src`
  * attribute names are appended past the file's end.
  */
+import { isPathRelativeURL, startsRelativePath } from "./paths.js";
 const LANGUAGES = new Map([
     ["ts", "ts"],
     ["tsx", "tsx"],
@@ -346,10 +347,10 @@ function actionOf(text) {
 /** Whether a `src` value names a file: no scheme, no root-relative path, not empty. */
 function specifierOf(value) {
     const trimmed = value.trim();
-    if (trimmed === "" || trimmed.startsWith("/") || /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(trimmed)) {
+    if (!isPathRelativeURL(trimmed)) {
         return undefined;
     }
-    return trimmed.startsWith("./") || trimmed.startsWith("../") ? trimmed : `./${trimmed}`;
+    return startsRelativePath(trimmed) ? trimmed : `./${trimmed}`;
 }
 /** The line-start `<script` tags one block's content holds. */
 function scriptsInside(text, from, to) {

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:4a66f7f01b0f1a23cf843b77ef48d762f2dcf486153e665560f107f10b0ea838",
+        digest: "sha256:a4ffbc1c2d9dc7903ccbf52af0e1a22094e0b50363f59365f6aa37b9437d3427",
     },
     gaps: [],
 };

package/dist/src/consumers.js

@@ -1,22 +1,21 @@
+import { runDirectories } from "./entries/run-directories.js";
 import { inventory } from "./inventory/enumerate.js";
 import { relativePath } from "./paths.js";
 import { references } from "./references.js";
 import { narrowedTo } from "./session.js";
+import { patternTestFile } from "./tests/file-class.js";
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
  * The target's declarations are enumerated over the target's files the consumer's
  * program holds, against the target root, so each carries the identifier the target's
- * own projects give it. A reference from a consumer's test file is a test reference
- * unless the configuration counts it as a production one.
+ * own projects give it. A reference from a consumer's test file is a test reference;
+ * whether the run counts it as a production one is the sweep's mode.
  */
-export function consumerReferences(project, host, targetRoot, consumer, config) {
+export function consumerReferences(project, host, targetRoot, consumer, config, parse) {
     const held = inventory(narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined), host, targetRoot);
-    const found = references(project, held, targetRoot, {
-        testFiles: config.ts.test_files,
+    return references(project, held, targetRoot, {
+        testFile: patternTestFile(config.ts.test_files, consumer.root),
         consumer,
-    }).references;
-    if (config.analysis.consumer_tests !== "production") {
-        return found;
-    }
-    return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));
+        directories: runDirectories(host, consumer.root, parse),
+    });
 }