vibecodedshit 0.0.0-stage → 0.2.0

package/dist/measure/p6-5.js

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { pythonEnvReads } from '../python/env.js';
+import { readTracked } from '../scope/tracked.js';
+import { dirsUpward } from './ops/entry-points.js';
+import { parseEnvExample } from './ops/env-example.js';
+import { isExcludedEnvName, tsEnvReads } from './ops/env-reads.js';
+import { runtimePinned } from './ops/runtime.js';
+import { logicUnits } from './units.js';
+export const p65 = {
+    id: '6.5',
+    layer: 'static',
+    async measure({ scope, repoPath, methodology }) {
+        const lists = methodology.d6;
+        const warnings = [];
+        const pyFiles = scope.files.filter((f) => f.group === 'python' && f.role === 'logic').map((f) => f.path);
+        const pyReads = pyFiles.length === 0 ? {} : pythonEnvReads(repoPath, pyFiles);
+        const units = logicUnits(scope).map((unit) => {
+            const read = new Set();
+            for (const file of unit.files) {
+                if (unit.group === 'python') {
+                    const found = pyReads[file.path];
+                    if (found?.ok)
+                        for (const name of found.names)
+                            read.add(name);
+                    else
+                        warnings.push(`6.5: ${file.path}: syntax error, its environment reads are not counted`);
+                }
+                else
+                    for (const name of tsEnvReads(scope.getTsSourceFile(file.path)))
+                        read.add(name);
+            }
+            const names = [...read].filter((name) => !isExcludedEnvName(name, lists));
+            let documented = new Set();
+            search: for (const dir of dirsUpward(unit.dir)) {
+                for (const name of lists.envExampleFiles) {
+                    const text = readTracked(repoPath, path.posix.join(dir, name));
+                    if (text !== null) {
+                        documented = new Set(Object.keys(parseEnvExample(text)));
+                        break search;
+                    }
+                }
+            }
+            const numerator = names.filter((name) => documented.has(name)).length;
+            const pinned = runtimePinned(repoPath, unit.dir, unit.group, lists.runtimePinFiles, warnings);
+            return {
+                package: unit.package,
+                group: unit.group,
+                weight: unit.weight,
+                raw: {
+                    kind: 'components',
+                    components: {
+                        runtime_pinned: { kind: 'level', level: pinned ? 'yes' : 'no' },
+                        env_documented: { kind: 'ratio', numerator, denominator: names.length, scale: 100, ...(names.length === 0 ? { emptyScore: 100 } : {}) },
+                    },
+                },
+            };
+        });
+        return { status: 'measured', units, ...(warnings.length === 0 ? {} : { warnings: [...new Set(warnings)] }) };
+    },
+};

package/dist/measure/p6-6.js

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import { readTracked, trackedPaths } from '../scope/tracked.js';
+import { extractCommands } from './ops/docs-commands.js';
+import { DocResolver } from './ops/docs-resolve.js';
+import { logicUnits } from './units.js';
+const AGENT_FILES = ['agents.md', 'claude.md'];
+const README_NAMES = ['readme.md', 'readme', 'readme.rst', 'readme.txt'];
+/** The tracked file of `dir` whose name matches one of `names` case-insensitively, in the order of `names`. */
+function findCi(tracked, dir, names) {
+    const inDir = tracked.filter((f) => path.posix.dirname(f) === dir);
+    for (const name of names) {
+        const found = inDir.find((f) => path.posix.basename(f).toLowerCase() === name);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+export const p66 = {
+    id: '6.6',
+    layer: 'static',
+    async measure({ scope, repoPath, methodology }) {
+        const lists = methodology.d6;
+        const tracked = trackedPaths(repoPath);
+        const words = {
+            commandWords: new Set([
+                ...lists.docPackageManagers,
+                ...[...lists.typecheckers, ...lists.linters, ...lists.testRunners].map((t) => (t === 'node --test' ? 'node' : t.replace(/^python3? -m /, ''))),
+            ]),
+        };
+        const resolver = new DocResolver(repoPath, lists);
+        const commandsOf = (file) => {
+            const text = file === undefined ? null : readTracked(repoPath, file);
+            return text === null ? [] : extractCommands(text, words);
+        };
+        const agentFiles = AGENT_FILES.flatMap((name) => findCi(tracked, '.', [name]) ?? []);
+        const agent = agentFiles.flatMap((file) => commandsOf(file).map((command) => ({ file, command })));
+        const unresolved = agent.filter(({ command }) => !resolver.resolves(command, '.'));
+        const warnings = unresolved.slice(0, 5).map(({ file, command }) => `6.6: ${file}:${command.line}: \`${command.text}\` does not resolve`);
+        const rootReadme = findCi(tracked, '.', README_NAMES);
+        const rootReadmeHasCommands = commandsOf(rootReadme).length > 0;
+        const units = logicUnits(scope).map((unit) => {
+            let level;
+            if (agent.length > 0)
+                level = unresolved.length === 0 ? 'agent_file' : 'readme';
+            else {
+                const own = unit.dir === '.' ? undefined : findCi(tracked, unit.dir, README_NAMES);
+                const hasCommands = own !== undefined && commandsOf(own).length > 0 ? true : rootReadmeHasCommands;
+                level = hasCommands ? 'readme' : 'none';
+            }
+            return { package: unit.package, group: unit.group, weight: unit.weight, raw: { kind: 'level', level } };
+        });
+        return { status: 'measured', units, ...(warnings.length === 0 ? {} : { warnings }) };
+    },
+};

package/dist/measure/py/typecheck-config.js

@@ -0,0 +1,95 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+import { parseIni } from '../../util/ini.js';
+import { readToml } from '../../util/toml.js';
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function truthy(value) {
+    if (typeof value === 'boolean')
+        return value;
+    return typeof value === 'string' && ['true', '1', 'yes', 'on'].includes(value.trim().toLowerCase());
+}
+function pyrightLevel(mode, unsetMeans, basedpyright) {
+    if (typeof mode !== 'string')
+        return unsetMeans;
+    switch (mode) {
+        case 'off':
+            return 'none';
+        case 'basic':
+            return 'basic';
+        case 'standard':
+            return 'standard';
+        case 'strict':
+            return 'strict';
+        case 'recommended':
+        case 'all':
+            return basedpyright ? 'strict' : unsetMeans;
+        default:
+            return unsetMeans;
+    }
+}
+function mypyLevel(section) {
+    if (truthy(section.strict))
+        return 'strict';
+    if (truthy(section.disallow_untyped_defs) && truthy(section.check_untyped_defs))
+        return 'standard';
+    return 'basic';
+}
+function readText(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The level one directory declares, or undefined when it holds no pyright or mypy config. pyright wins over mypy. */
+function levelInDirectory(dir, relDir, warnings) {
+    const rel = (name) => (relDir === '' ? name : `${relDir}/${name}`);
+    const pyproject = existsSync(path.join(dir, 'pyproject.toml')) ? readToml(path.join(dir, 'pyproject.toml')) : undefined;
+    if (existsSync(path.join(dir, 'pyproject.toml')) && pyproject === undefined) {
+        warnings.push(`2.2: ${rel('pyproject.toml')}: invalid TOML, ignored`);
+    }
+    const tool = asRecord(pyproject?.tool);
+    const pyrightJson = readText(path.join(dir, 'pyrightconfig.json'));
+    if (pyrightJson !== undefined) {
+        const parsed = ts.parseConfigFileTextToJson('pyrightconfig.json', pyrightJson);
+        if (parsed.error)
+            warnings.push(`2.2: ${rel('pyrightconfig.json')}: invalid JSON, ignored`);
+        else
+            return pyrightLevel(asRecord(parsed.config)?.typeCheckingMode, 'standard', false);
+    }
+    const pyright = asRecord(tool?.pyright);
+    if (pyright)
+        return pyrightLevel(pyright.typeCheckingMode, 'standard', false);
+    const basedpyright = asRecord(tool?.basedpyright);
+    if (basedpyright)
+        return pyrightLevel(basedpyright.typeCheckingMode, 'strict', true);
+    for (const name of ['mypy.ini', '.mypy.ini']) {
+        const text = readText(path.join(dir, name));
+        const section = text === undefined ? undefined : parseIni(text).mypy;
+        if (section)
+            return mypyLevel(section);
+    }
+    const mypyToml = asRecord(tool?.mypy);
+    if (mypyToml)
+        return mypyLevel(mypyToml);
+    const setupCfg = readText(path.join(dir, 'setup.cfg'));
+    const cfgSection = setupCfg === undefined ? undefined : parseIni(setupCfg).mypy;
+    if (cfgSection)
+        return mypyLevel(cfgSection);
+    return undefined;
+}
+/** Search from the unit's package directory up to the repository root; the first directory with a config decides. */
+export function pythonLevel(repoPath, packageDir, warnings) {
+    const parts = packageDir === '.' ? [] : packageDir.split('/');
+    for (let depth = parts.length; depth >= 0; depth -= 1) {
+        const relDir = parts.slice(0, depth).join('/');
+        const level = levelInDirectory(path.join(repoPath, relDir), relDir, warnings);
+        if (level !== undefined)
+            return level;
+    }
+    return 'none';
+}

package/dist/measure/registry.js

@@ -0,0 +1,31 @@
+import { p11 } from './p1-1.js';
+import { p12 } from './p1-2.js';
+import { p13 } from './p1-3.js';
+import { p14 } from './p1-4.js';
+import { p15 } from './p1-5.js';
+import { p21 } from './p2-1.js';
+import { p22 } from './p2-2.js';
+import { p23 } from './p2-3.js';
+import { p24 } from './p2-4.js';
+import { p25 } from './p2-5.js';
+import { p31 } from './p3-1.js';
+import { p32 } from './p3-2.js';
+import { p33 } from './p3-3.js';
+import { p34 } from './p3-4.js';
+import { p35 } from './p3-5.js';
+import { p41 } from './p4-1.js';
+import { p42 } from './p4-2.js';
+import { p43 } from './p4-3.js';
+import { p44 } from './p4-4.js';
+import { p51 } from './p5-1.js';
+import { p52 } from './p5-2.js';
+import { p53 } from './p5-3.js';
+import { p54 } from './p5-4.js';
+import { p55 } from './p5-5.js';
+import { p61 } from './p6-1.js';
+import { p62 } from './p6-2.js';
+import { p63 } from './p6-3.js';
+import { p64 } from './p6-4.js';
+import { p65 } from './p6-5.js';
+import { p66 } from './p6-6.js';
+export const measurers = [p11, p12, p13, p14, p15, p21, p22, p23, p24, p25, p31, p32, p33, p34, p35, p41, p42, p43, p44, p51, p52, p53, p54, p55, p61, p62, p63, p64, p65, p66];

package/dist/measure/safety/py-tests.js

@@ -0,0 +1,124 @@
+import path from 'node:path';
+import { pythonTestFacts } from '../../python/tests.js';
+import { trackedPaths } from '../../scope/tracked.js';
+/** Resolution of Python imports to tracked files, for 1.4. Third-party and stdlib imports resolve to nothing. */
+export class PyImportGraph {
+    tracked;
+    facts;
+    packageOf = new Map();
+    constructor(repoPath, files) {
+        this.tracked = new Set(trackedPaths(repoPath));
+        this.facts = pythonTestFacts(repoPath);
+        for (const file of files)
+            this.packageOf.set(file.path, file.package);
+    }
+    factsOf(file) {
+        return this.facts[file];
+    }
+    /** The directories an absolute import is tried from, in order: the importer's own directory, `<P>/src`, `<P>`, `src`, `.`. */
+    roots(from) {
+        const pkg = this.packageOf.get(from) ?? '.';
+        const candidates = [path.posix.dirname(from), pkg === '.' ? 'src' : `${pkg}/src`, pkg, 'src', '.'];
+        return [...new Set(candidates)];
+    }
+    moduleIn(dir, parts) {
+        const base = parts.length === 0 ? dir : path.posix.join(dir, ...parts);
+        for (const candidate of parts.length === 0 ? [path.posix.join(base, '__init__.py')] : [`${base}.py`, path.posix.join(base, '__init__.py')]) {
+            if (this.tracked.has(path.posix.normalize(candidate)))
+                return path.posix.normalize(candidate);
+        }
+        return undefined;
+    }
+    /** The file of `module` as imported from `from` (a relative import uses its `level`; an absolute one tries each root, first hit wins). */
+    moduleFile(from, level, module) {
+        const parts = module === null ? [] : module.split('.');
+        if (level > 0) {
+            let dir = path.posix.dirname(from);
+            for (let i = 1; i < level; i += 1)
+                dir = path.posix.dirname(dir);
+            return this.moduleIn(dir, parts);
+        }
+        if (parts.length === 0)
+            return undefined;
+        for (const root of this.roots(from)) {
+            const found = this.moduleIn(root, parts);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    lookupIn(file, name, seen) {
+        const key = `${file}\0${name}`;
+        if (seen.has(key))
+            return undefined;
+        seen.add(key);
+        const facts = this.facts[file];
+        if (!facts?.ok)
+            return undefined;
+        if (facts.defined.includes(name))
+            return file;
+        const binding = facts.reexports.find((r) => r.name === name);
+        return binding ? this.fromImport(file, binding.level, binding.module, binding.orig, seen) : undefined;
+    }
+    /** The file that defines `name` imported by `from <module> import name` in `from`, following `__init__.py` re-exports; a submodule is credited itself. */
+    fromImport(from, level, module, name, seen = new Set()) {
+        const target = this.moduleFile(from, level, module);
+        if (target) {
+            const found = this.lookupIn(target, name, seen);
+            if (found)
+                return found;
+        }
+        const dir = target === undefined ? (module === null && level > 0 ? this.levelDir(from, level) : undefined) : target.endsWith('/__init__.py') || target === '__init__.py' ? path.posix.dirname(target) : undefined;
+        if (dir !== undefined) {
+            const sub = this.moduleIn(dir, [name]);
+            if (sub)
+                return sub;
+        }
+        return target;
+    }
+    levelDir(from, level) {
+        let dir = path.posix.dirname(from);
+        for (let i = 1; i < level; i += 1)
+            dir = path.posix.dirname(dir);
+        return dir;
+    }
+    /** Every file a star import of `file` reaches: the module itself and the targets of all its re-export bindings. */
+    starTargets(file) {
+        const facts = this.facts[file];
+        const out = [file];
+        if (facts?.ok) {
+            for (const binding of facts.reexports) {
+                const found = this.fromImport(file, binding.level, binding.module, binding.orig);
+                if (found !== undefined)
+                    out.push(found);
+            }
+        }
+        return out;
+    }
+    /** The files a test file credits through its imports. */
+    credits(test) {
+        const facts = this.facts[test];
+        if (!facts?.ok)
+            return [];
+        const out = [];
+        for (const imp of facts.imports) {
+            if (imp.names.length === 0 && !imp.star) {
+                const file = this.moduleFile(test, imp.level, imp.module);
+                if (file !== undefined)
+                    out.push(file);
+                continue;
+            }
+            for (const { name } of imp.names) {
+                const found = this.fromImport(test, imp.level, imp.module, name);
+                if (found !== undefined)
+                    out.push(found);
+            }
+            if (imp.star) {
+                const file = this.moduleFile(test, imp.level, imp.module);
+                if (file !== undefined)
+                    out.push(...this.starTargets(file));
+            }
+        }
+        return out;
+    }
+}

package/dist/measure/safety/ts-barrels.js

@@ -0,0 +1,68 @@
+import ts from 'typescript';
+const hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((m) => m.kind === kind);
+function bindingNames(name, out) {
+    if (ts.isIdentifier(name))
+        out.push(name.text);
+    else
+        for (const el of name.elements)
+            if (ts.isBindingElement(el))
+                bindingNames(el.name, out);
+}
+export function summarize(sf) {
+    const summary = { defined: new Set(), named: new Map(), stars: [], namespaces: new Map() };
+    const imports = new Map();
+    for (const stmt of sf.statements) {
+        if (ts.isImportDeclaration(stmt) && ts.isStringLiteralLike(stmt.moduleSpecifier) && stmt.importClause) {
+            const specifier = stmt.moduleSpecifier.text;
+            const clause = stmt.importClause;
+            if (clause.name)
+                imports.set(clause.name.text, { specifier, orig: 'default' });
+            if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+                for (const el of clause.namedBindings.elements)
+                    imports.set(el.name.text, { specifier, orig: (el.propertyName ?? el.name).text });
+            }
+        }
+    }
+    for (const stmt of sf.statements) {
+        if (ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt) || ts.isEnumDeclaration(stmt) || ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) {
+            if (stmt.name)
+                summary.defined.add(stmt.name.text);
+            if (hasModifier(stmt, ts.SyntaxKind.DefaultKeyword))
+                summary.defined.add('default');
+        }
+        else if (ts.isVariableStatement(stmt)) {
+            const names = [];
+            for (const decl of stmt.declarationList.declarations)
+                bindingNames(decl.name, names);
+            for (const name of names)
+                summary.defined.add(name);
+        }
+        else if (ts.isExportAssignment(stmt)) {
+            summary.defined.add('default');
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            const from = stmt.moduleSpecifier && ts.isStringLiteralLike(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : undefined;
+            const clause = stmt.exportClause;
+            if (from !== undefined) {
+                if (!clause)
+                    summary.stars.push(from);
+                else if (ts.isNamespaceExport(clause))
+                    summary.namespaces.set(clause.name.text, from);
+                else
+                    for (const el of clause.elements)
+                        summary.named.set(el.name.text, { specifier: from, orig: (el.propertyName ?? el.name).text });
+            }
+            else if (clause && ts.isNamedExports(clause)) {
+                for (const el of clause.elements) {
+                    const local = (el.propertyName ?? el.name).text;
+                    const imported = imports.get(local);
+                    if (imported)
+                        summary.named.set(el.name.text, imported);
+                    else
+                        summary.defined.add(el.name.text);
+                }
+            }
+        }
+    }
+    return summary;
+}

package/dist/measure/safety/ts-cases.js

@@ -0,0 +1,111 @@
+import ts from 'typescript';
+const CASE_ROOTS = new Set(['it', 'test']);
+const CASE_MODIFIERS = new Set(['only', 'concurrent']);
+const EACH_MODIFIERS = new Set(['only', 'concurrent', 'each']);
+/** `it`, `test` or `it.only.each` as a root identifier and the property names after it, or undefined for anything else. */
+function chainOf(expr) {
+    const mods = [];
+    let current = expr;
+    while (ts.isPropertyAccessExpression(current)) {
+        mods.unshift(current.name.text);
+        current = current.expression;
+    }
+    return ts.isIdentifier(current) ? { root: current.text, mods } : undefined;
+}
+/**
+ * A test case is a call to `it` or `test`, or to `it`/`test` followed by a chain of `.only` and `.concurrent`, or `.each(...)` (call or
+ * tagged template) and then the call itself. `.skip`, `.todo`, `.fails`, `.skipIf` and `.runIf` are not counted; `describe` is not a case.
+ */
+function isCaseCall(call) {
+    const callee = call.expression;
+    const direct = chainOf(callee);
+    if (direct)
+        return CASE_ROOTS.has(direct.root) && direct.mods.every((m) => CASE_MODIFIERS.has(m));
+    const each = ts.isCallExpression(callee) ? callee.expression : ts.isTaggedTemplateExpression(callee) ? callee.tag : undefined;
+    const chain = each ? chainOf(each) : undefined;
+    return chain !== undefined && CASE_ROOTS.has(chain.root) && chain.mods.at(-1) === 'each' && chain.mods.every((m) => EACH_MODIFIERS.has(m));
+}
+const isFunctionLike = (node) => ts.isArrowFunction(node) || ts.isFunctionExpression(node);
+function isAssertionCall(call, testParam) {
+    const callee = call.expression;
+    if (ts.isIdentifier(callee))
+        return ['expect', 'assert', 'expectTypeOf'].includes(callee.text);
+    if (!ts.isPropertyAccessExpression(callee))
+        return false;
+    const props = [];
+    let root = callee;
+    while (ts.isPropertyAccessExpression(root)) {
+        props.unshift(root.name.text);
+        root = root.expression;
+    }
+    if (!ts.isIdentifier(root))
+        return false;
+    if (root.text === 'expect')
+        return props.length === 1 && (props[0] === 'soft' || props[0] === 'poll');
+    if (root.text === 'assert')
+        return true;
+    if (testParam !== undefined && root.text === testParam) {
+        const [first] = props;
+        return first !== undefined && (first.startsWith('assert') || (props.length === 1 && (first === 'is' || first === 'deepEqual')));
+    }
+    return false;
+}
+function containsAssertion(node, testParam, calls) {
+    let found = false;
+    const visit = (child) => {
+        if (found && calls === undefined)
+            return;
+        if (ts.isCallExpression(child)) {
+            if (isAssertionCall(child, testParam))
+                found = true;
+            calls?.push(child);
+        }
+        ts.forEachChild(child, visit);
+    };
+    visit(node);
+    return found;
+}
+/** Functions declared in the file by name: function declarations and `const x = <arrow or function expression>`. */
+function helpersOf(sf) {
+    const helpers = new Map();
+    const visit = (node) => {
+        if (ts.isFunctionDeclaration(node) && node.name && node.body)
+            helpers.set(node.name.text, node.body);
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && isFunctionLike(node.initializer))
+            helpers.set(node.name.text, node.initializer.body);
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return helpers;
+}
+/**
+ * The test cases of a file. Assertions: `expect(...)`, `expect.soft`, `expect.poll`, `assert(...)`, `assert.*`, `expectTypeOf(...)` and
+ * `t.assert*`, `t.is`, `t.deepEqual` where `t` is the callback's first parameter, searched in the whole body. A call to a helper declared in
+ * the same file counts when the helper's body directly contains an assertion (one level). A case with no function argument has no assertion.
+ */
+export function testCases(sf) {
+    const helpers = helpersOf(sf);
+    const cases = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && isCaseCall(node)) {
+            const callback = [...node.arguments].reverse().find(isFunctionLike);
+            let asserts = false;
+            if (callback) {
+                const first = callback.parameters[0];
+                const testParam = first && ts.isIdentifier(first.name) ? first.name.text : undefined;
+                const calls = [];
+                asserts = containsAssertion(callback.body, testParam, calls);
+                if (!asserts) {
+                    asserts = calls.some((call) => {
+                        const helper = ts.isIdentifier(call.expression) ? helpers.get(call.expression.text) : undefined;
+                        return helper !== undefined && containsAssertion(helper, undefined);
+                    });
+                }
+            }
+            cases.push({ line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1, asserts });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return cases;
+}

package/dist/measure/safety/ts-credits.js

@@ -0,0 +1,101 @@
+import { readTracked } from '../../scope/tracked.js';
+import { parseTsFile } from '../../scope/ts-lines.js';
+import { summarize } from './ts-barrels.js';
+import { importFacts, namespaceAccesses } from './ts-imports.js';
+/** Logic files of the TS/JS group credited by the imports of one test file, with barrels followed to the defining file. */
+export class TsCredits {
+    repoPath;
+    scope;
+    resolver;
+    summaries = new Map();
+    parsed = new Map();
+    constructor(repoPath, scope, resolver) {
+        this.repoPath = repoPath;
+        this.scope = scope;
+        this.resolver = resolver;
+    }
+    /** A scoped file from the scope's cache; a barrel or other out-of-scope tracked file is parsed from its text. */
+    source(file) {
+        const cached = this.parsed.get(file);
+        if (cached !== undefined)
+            return cached ?? undefined;
+        let sf = null;
+        try {
+            sf = this.scope.getTsSourceFile(file);
+        }
+        catch {
+            const text = readTracked(this.repoPath, file);
+            sf = text === null ? null : parseTsFile(file, text);
+        }
+        this.parsed.set(file, sf);
+        return sf ?? undefined;
+    }
+    summary(file) {
+        const cached = this.summaries.get(file);
+        if (cached !== undefined)
+            return cached ?? undefined;
+        const sf = this.source(file);
+        const summary = sf ? summarize(sf) : null;
+        this.summaries.set(file, summary);
+        return summary ?? undefined;
+    }
+    /** The file defining `name` as exported by `start`: breadth first through `export *` sources, first definition wins. */
+    define(start, name, seen) {
+        const queue = [start];
+        while (queue.length > 0) {
+            const file = queue.shift();
+            const key = `${file}\0${name}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const summary = this.summary(file);
+            if (!summary)
+                continue;
+            if (summary.defined.has(name))
+                return file;
+            const named = summary.named.get(name);
+            if (named) {
+                const target = this.resolver.resolve(named.specifier, file);
+                if (target !== undefined)
+                    return this.define(target, named.orig, seen) ?? target;
+            }
+            const namespace = summary.namespaces.get(name);
+            if (namespace !== undefined) {
+                const target = this.resolver.resolve(namespace, file);
+                if (target !== undefined)
+                    return target;
+            }
+            for (const star of summary.stars) {
+                const target = this.resolver.resolve(star, file);
+                if (target !== undefined)
+                    queue.push(target);
+            }
+        }
+        return undefined;
+    }
+    /** Every file the test file credits (callers keep only logic-role files). */
+    credits(test) {
+        const out = new Set();
+        const sf = this.source(test);
+        if (!sf)
+            return out;
+        const facts = importFacts(sf);
+        const namespaces = namespaceAccesses(sf, new Set(facts.flatMap((f) => (f.local === undefined ? [] : [f.local]))));
+        for (const fact of facts) {
+            const target = this.resolver.resolve(fact.specifier, test);
+            if (target === undefined)
+                continue;
+            if (fact.name === undefined || fact.name === '*') {
+                out.add(target);
+                for (const name of fact.local === undefined ? [] : [...(namespaces.get(fact.local) ?? [])]) {
+                    const defining = this.define(target, name, new Set());
+                    if (defining !== undefined)
+                        out.add(defining);
+                }
+            }
+            else
+                out.add(this.define(target, fact.name, new Set()) ?? target);
+        }
+        return out;
+    }
+}