vibecodedshit 0.0.0-stage → 0.3.0

package/dist/measure/ops/runtime.js

@@ -0,0 +1,73 @@
+import path from 'node:path';
+import { readPackageJson } from '../../manifest/package-json.js';
+import { readTracked } from '../../scope/tracked.js';
+import { parseTomlText } from '../../util/toml.js';
+import { dirsUpward } from './entry-points.js';
+const isObj = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const nonEmpty = (value) => (typeof value === 'string' && value.trim() !== '') || (Array.isArray(value) && value.some(nonEmpty));
+const fileHasContent = (name, group) => ({
+    group,
+    check: (repoPath, dir) => (readTracked(repoPath, path.posix.join(dir, name))?.trim() ?? '') !== '',
+});
+function toml(repoPath, file, warnings) {
+    const text = readTracked(repoPath, file);
+    if (text === null)
+        return undefined;
+    const doc = parseTomlText(text);
+    if (!doc)
+        warnings.push(`6.5: ${file} is not valid TOML, so it does not pin a runtime`);
+    return doc;
+}
+const toolVersions = (tools, group) => ({
+    group,
+    check: (repoPath, dir) => (readTracked(repoPath, path.posix.join(dir, '.tool-versions')) ?? '')
+        .split('\n')
+        .some((line) => {
+        const [tool, version] = line.trim().split(/\s+/);
+        return tool !== undefined && tools.includes(tool) && version !== undefined && !version.startsWith('#');
+    }),
+});
+const mise = (tools, group) => ({
+    group,
+    check(repoPath, dir, warnings) {
+        const doc = toml(repoPath, path.posix.join(dir, 'mise.toml'), warnings);
+        const table = doc && isObj(doc.tools) ? doc.tools : {};
+        return tools.some((tool) => nonEmpty(table[tool]));
+    },
+});
+/** The pin files of the 6.5 `runtime_pinned` measure, by the words the YAML uses; a word the YAML adds that is not here pins nothing. */
+const PROBES = {
+    '.nvmrc': [fileHasContent('.nvmrc', 'typescript_javascript')],
+    '.node-version': [fileHasContent('.node-version', 'typescript_javascript')],
+    '.tool-versions': [toolVersions(['node', 'nodejs'], 'typescript_javascript'), toolVersions(['python'], 'python')],
+    'mise.toml': [mise(['node', 'nodejs'], 'typescript_javascript'), mise(['python'], 'python')],
+    'engines.node in package.json': [
+        { group: 'typescript_javascript', check: (repoPath, dir) => nonEmpty(readPackageJson(repoPath, dir)?.engines.node) },
+    ],
+    'volta in package.json': [
+        { group: 'typescript_javascript', check: (repoPath, dir) => nonEmpty(readPackageJson(repoPath, dir)?.volta?.node) },
+    ],
+    '.python-version': [fileHasContent('.python-version', 'python')],
+    'requires-python in pyproject.toml': [
+        {
+            group: 'python',
+            check(repoPath, dir, warnings) {
+                const doc = toml(repoPath, path.posix.join(dir, 'pyproject.toml'), warnings);
+                return doc !== undefined && isObj(doc.project) && nonEmpty(doc.project['requires-python']);
+            },
+        },
+    ],
+    'runtime.txt': [fileHasContent('runtime.txt', 'python')],
+};
+/** Looked up at the unit's package directory, then each ancestor up to the repository root. Poetry's `python = "^3.12"` dependency does not count. */
+export function runtimePinned(repoPath, dir, group, pinFiles, warnings) {
+    for (const d of dirsUpward(dir)) {
+        for (const word of pinFiles) {
+            for (const probe of PROBES[word] ?? []) {
+                if (probe.group === group && probe.check(repoPath, d, warnings))
+                    return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/measure/p1-1.js

@@ -0,0 +1,8 @@
+import { measurePassRate } from '../exec/tests.js';
+export const p11 = {
+    id: '1.1',
+    layer: 'execution',
+    async measure(ctx) {
+        return measurePassRate(ctx);
+    },
+};

package/dist/measure/p1-2.js

@@ -0,0 +1,8 @@
+import { measureCoverage } from '../exec/tests.js';
+export const p12 = {
+    id: '1.2',
+    layer: 'execution',
+    async measure(ctx) {
+        return measureCoverage(ctx, 'lines');
+    },
+};

package/dist/measure/p1-3.js

@@ -0,0 +1,8 @@
+import { measureCoverage } from '../exec/tests.js';
+export const p13 = {
+    id: '1.3',
+    layer: 'execution',
+    async measure(ctx) {
+        return measureCoverage(ctx, 'branches');
+    },
+};

package/dist/measure/p1-4.js

@@ -0,0 +1,41 @@
+import { PyImportGraph } from './safety/py-tests.js';
+import { TsCredits } from './safety/ts-credits.js';
+import { createTsResolver } from './safety/ts-resolve.js';
+import { logicUnits } from './units.js';
+export const p14 = {
+    id: '1.4',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const units = logicUnits(scope);
+        const warnings = [];
+        const credited = new Set();
+        const tsTests = scope.files.filter((f) => f.role === 'test' && f.group === 'typescript_javascript');
+        if (tsTests.length > 0 && units.some((u) => u.group === 'typescript_javascript')) {
+            const credits = new TsCredits(repoPath, scope, createTsResolver(repoPath));
+            for (const test of tsTests)
+                for (const file of credits.credits(test.path))
+                    credited.add(file);
+        }
+        const pyFiles = scope.files.filter((f) => f.group === 'python');
+        const pyTests = pyFiles.filter((f) => f.role === 'test');
+        if (pyTests.length > 0 && units.some((u) => u.group === 'python')) {
+            const graph = new PyImportGraph(repoPath, pyFiles);
+            for (const test of pyTests) {
+                if (graph.factsOf(test.path)?.ok === false)
+                    warnings.push(`1.4: ${test.path}: syntax error, its imports are not counted`);
+                for (const file of graph.credits(test.path))
+                    credited.add(file);
+            }
+        }
+        return {
+            status: 'measured',
+            units: units.map((unit) => ({
+                package: unit.package,
+                group: unit.group,
+                weight: unit.weight,
+                raw: { kind: 'ratio', numerator: unit.files.filter((f) => credited.has(f.path)).length, denominator: unit.files.length, scale: 100 },
+            })),
+            ...(warnings.length === 0 ? {} : { warnings }),
+        };
+    },
+};

package/dist/measure/p1-5.js

@@ -0,0 +1,59 @@
+import { pythonTestFacts } from '../python/tests.js';
+import { testCases } from './safety/ts-cases.js';
+import { TsCredits } from './safety/ts-credits.js';
+import { createTsResolver } from './safety/ts-resolve.js';
+import { logicUnits, unitId } from './units.js';
+export const p15 = {
+    id: '1.5',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const units = logicUnits(scope);
+        const tallies = new Map(units.map((u) => [unitId(u), { numerator: 0, denominator: 0 }]));
+        const warnings = [];
+        const tsTests = scope.files.filter((f) => f.role === 'test' && f.group === 'typescript_javascript' && tallies.has(unitId(f)));
+        if (tsTests.length > 0) {
+            const credits = new TsCredits(repoPath, scope, createTsResolver(repoPath));
+            for (const test of tsTests) {
+                const sf = credits.source(test.path);
+                const tally = tallies.get(unitId(test));
+                if (!sf || !tally)
+                    continue;
+                for (const found of testCases(sf)) {
+                    tally.denominator += 1;
+                    if (found.asserts)
+                        tally.numerator += 1;
+                }
+            }
+        }
+        const pyFiles = scope.files.filter((f) => f.group === 'python');
+        const pyTests = pyFiles.filter((f) => f.role === 'test' && tallies.has(unitId(f)));
+        if (pyTests.length > 0) {
+            const facts = pythonTestFacts(repoPath);
+            for (const test of pyTests) {
+                const info = facts[test.path];
+                const tally = tallies.get(unitId(test));
+                if (!tally)
+                    continue;
+                if (!info?.ok) {
+                    warnings.push(`1.5: ${test.path}: syntax error, its test cases are not counted`);
+                    continue;
+                }
+                for (const found of info.cases) {
+                    tally.denominator += 1;
+                    if (found.asserts)
+                        tally.numerator += 1;
+                }
+            }
+        }
+        return {
+            status: 'measured',
+            units: units.map((unit) => ({
+                package: unit.package,
+                group: unit.group,
+                weight: unit.weight,
+                raw: { kind: 'ratio', ...tallies.get(unitId(unit)), scale: 100 },
+            })),
+            ...(warnings.length === 0 ? {} : { warnings }),
+        };
+    },
+};

package/dist/measure/p2-1.js

@@ -0,0 +1,8 @@
+import { measureFindings } from '../exec/findings.js';
+export const p21 = {
+    id: '2.1',
+    layer: 'execution',
+    async measure(ctx) {
+        return measureFindings(ctx, (exec) => exec.typecheck);
+    },
+};

package/dist/measure/p2-2.js

@@ -0,0 +1,44 @@
+import path from 'node:path';
+import { pythonLevel } from './py/typecheck-config.js';
+import { levelOf, lowestLevel, unitConfigs } from './ts/tsconfig.js';
+import { emptyTallies, logicFiles } from './units.js';
+const TS_SOURCE = /\.(?:ts|tsx|mts|cts)$/i;
+export const p22 = {
+    id: '2.2',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const warnings = [];
+        const cache = new Map();
+        const warned = new Set();
+        const units = [];
+        const tsFiles = logicFiles(scope, 'typescript_javascript');
+        for (const tally of emptyTallies(tsFiles).values()) {
+            const unitFiles = tsFiles.filter((f) => f.package === tally.package).map((f) => f.path);
+            const { configs, read } = unitConfigs(repoPath, tally.package, unitFiles, cache);
+            for (const config of read) {
+                for (const missing of config.missingExtends) {
+                    const message = `2.2: ${path.posix.relative(repoPath.split(path.sep).join('/'), config.file)} extends ${missing}, which could not be resolved; level computed without it`;
+                    if (!warned.has(message)) {
+                        warned.add(message);
+                        warnings.push(message);
+                    }
+                }
+            }
+            const hasTypeScript = unitFiles.some((f) => TS_SOURCE.test(f));
+            const levels = configs.map((c) => (!hasTypeScript && c.options.checkJs !== true ? 'none' : levelOf(c.options)));
+            const level = levels.length === 0 ? 'none' : lowestLevel(levels);
+            units.push({ package: tally.package, group: tally.group, weight: tally.weight, raw: { kind: 'level', level } });
+        }
+        const pyFiles = logicFiles(scope, 'python');
+        for (const tally of emptyTallies(pyFiles).values()) {
+            units.push({
+                package: tally.package,
+                group: tally.group,
+                weight: tally.weight,
+                raw: { kind: 'level', level: pythonLevel(repoPath, tally.package, warnings) },
+            });
+        }
+        units.sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group));
+        return { status: 'measured', units, warnings: [...new Set(warnings)] };
+    },
+};

package/dist/measure/p2-3.js

@@ -0,0 +1,81 @@
+import ts from 'typescript';
+import { analyzePythonTyping } from '../python/typing.js';
+import { countSuppressionComments, hasLeadingDirective } from './ts/directives.js';
+import { emptyTallies, logicFiles, unitId } from './units.js';
+const FILE_LEVEL_OPT_OUT = 10;
+function isConstType(type) {
+    return ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && type.typeName.text === 'const';
+}
+/** Escape-hatch points of one TypeScript or JavaScript file (methodology 2.3). */
+function countTsEscapeHatches(sourceFile) {
+    let points = 0;
+    const visit = (node) => {
+        switch (node.kind) {
+            case ts.SyntaxKind.AnyKeyword:
+            case ts.SyntaxKind.NonNullExpression:
+                points += 1;
+                break;
+            case ts.SyntaxKind.AsExpression:
+            case ts.SyntaxKind.TypeAssertionExpression:
+                if (!isConstType(node.type))
+                    points += 1;
+                break;
+            case ts.SyntaxKind.PropertyDeclaration:
+            case ts.SyntaxKind.VariableDeclaration:
+                if (node.exclamationToken)
+                    points += 1;
+                break;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    points += countSuppressionComments(sourceFile);
+    if (hasLeadingDirective(sourceFile, 'ts-nocheck'))
+        points += FILE_LEVEL_OPT_OUT;
+    return points;
+}
+export const p23 = {
+    id: '2.3',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const tsFiles = logicFiles(scope, 'typescript_javascript');
+        const pyFiles = logicFiles(scope, 'python');
+        const tallies = emptyTallies([...tsFiles, ...pyFiles]);
+        for (const file of tsFiles) {
+            const tally = tallies.get(unitId(file));
+            if (!tally)
+                continue;
+            tally.numerator += countTsEscapeHatches(scope.getTsSourceFile(file.path));
+            tally.denominator += file.logicLines;
+        }
+        const warnings = [];
+        const info = analyzePythonTyping(repoPath, pyFiles.map((f) => f.path));
+        let unparsed = 0;
+        for (const file of pyFiles) {
+            const tally = tallies.get(unitId(file));
+            const facts = info[file.path];
+            if (!tally)
+                continue;
+            if (!facts?.ok) {
+                unparsed += 1;
+                continue;
+            }
+            const p = facts.points;
+            tally.numerator +=
+                p.anyCount + p.castCount + p.typeIgnoreLine + p.pyrightIgnore +
+                    FILE_LEVEL_OPT_OUT * (p.typeIgnoreHeader + (p.mypyIgnoreErrors ? 1 : 0));
+            tally.denominator += file.logicLines;
+        }
+        if (unparsed > 0)
+            warnings.push(`2.3/2.4: ${unparsed} Python files could not be parsed`);
+        const units = [...tallies.values()]
+            .sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group))
+            .map((t) => ({
+            package: t.package,
+            group: t.group,
+            weight: t.weight,
+            raw: { kind: 'ratio', numerator: t.numerator, denominator: t.denominator, scale: 1000 },
+        }));
+        return { status: 'measured', units, warnings };
+    },
+};

package/dist/measure/p2-4.js

@@ -0,0 +1,288 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { analyzePythonTyping } from '../python/typing.js';
+import { hasLeadingDirective } from './ts/directives.js';
+import { unitConfigs } from './ts/tsconfig.js';
+import { emptyTallies, logicFiles, unitId } from './units.js';
+function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((m) => m.kind === kind) ?? false);
+}
+/** A function or arrow function behind parentheses, `satisfies T` and `as T`. */
+function functionOperand(expression) {
+    let contextual = false;
+    let current = expression;
+    for (;;) {
+        if (ts.isParenthesizedExpression(current))
+            current = current.expression;
+        else if (ts.isSatisfiesExpression(current)) {
+            contextual = true;
+            current = current.expression;
+        }
+        else if (ts.isAsExpression(current)) {
+            if (!(ts.isTypeReferenceNode(current.type) && current.type.getText() === 'const'))
+                contextual = true;
+            current = current.expression;
+        }
+        else
+            break;
+    }
+    return ts.isArrowFunction(current) || ts.isFunctionExpression(current) ? { node: current, contextual } : undefined;
+}
+/** Overload signatures with an implementation count as the implementation; without one, every signature counts. */
+function groupOverloads(nodes, keyOf) {
+    const byKey = new Map();
+    for (const node of nodes) {
+        const key = keyOf(node);
+        byKey.set(key, [...(byKey.get(key) ?? []), node]);
+    }
+    return [...byKey.values()].flatMap((group) => {
+        const impls = group.filter((n) => n.body !== undefined);
+        return impls.length > 0 ? impls : group;
+    });
+}
+function classSurface(node) {
+    const candidates = [];
+    const setters = [];
+    for (const member of node.members) {
+        if (ts.isMethodDeclaration(member) || ts.isConstructorDeclaration(member))
+            candidates.push(member);
+        else if (ts.isSetAccessorDeclaration(member))
+            setters.push(member);
+        else
+            continue;
+    }
+    const isPublic = (member) => !hasModifier(member, ts.SyntaxKind.PrivateKeyword) &&
+        !hasModifier(member, ts.SyntaxKind.ProtectedKeyword) &&
+        !(member.name !== undefined && ts.isPrivateIdentifier(member.name));
+    const methods = groupOverloads(candidates.filter(isPublic), (m) => `${hasModifier(m, ts.SyntaxKind.StaticKeyword) ? 'static ' : ''}${ts.isConstructorDeclaration(m) ? 'constructor' : m.name.getText()}`);
+    return [...methods, ...setters.filter(isPublic)].map((fn) => ({ node: fn, contextual: false }));
+}
+function isLocalFunctionValue(expression) {
+    return expression ? functionOperand(expression) : undefined;
+}
+/** Functions and function-valued variables declared at the top level of a file, by name. */
+function localFunctions(sourceFile) {
+    const byName = new Map();
+    const declarations = [];
+    for (const statement of sourceFile.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name)
+            declarations.push(statement);
+        else if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (!ts.isIdentifier(declaration.name))
+                    continue;
+                const surface = isLocalFunctionValue(declaration.initializer);
+                if (surface)
+                    byName.set(declaration.name.text, [{ ...surface, contextual: surface.contextual || declaration.type !== undefined }]);
+            }
+        }
+    }
+    for (const fn of groupOverloads(declarations, (d) => d.name?.text ?? '')) {
+        const name = fn.name?.text ?? '';
+        byName.set(name, [...(byName.get(name) ?? []), { node: fn, contextual: false }]);
+    }
+    return byName;
+}
+function publicSurface(sourceFile) {
+    const surface = new Map();
+    const add = (items) => {
+        for (const item of items)
+            surface.set(item.node, item);
+    };
+    const locals = localFunctions(sourceFile);
+    const exportedDeclarations = [];
+    for (const statement of sourceFile.statements) {
+        const exported = hasModifier(statement, ts.SyntaxKind.ExportKeyword);
+        if (ts.isFunctionDeclaration(statement) && exported)
+            exportedDeclarations.push(statement);
+        else if (ts.isClassDeclaration(statement) && exported)
+            add(classSurface(statement));
+        else if (ts.isVariableStatement(statement) && exported) {
+            for (const declaration of statement.declarationList.declarations) {
+                const fn = isLocalFunctionValue(declaration.initializer);
+                if (fn)
+                    add([{ ...fn, contextual: fn.contextual || declaration.type !== undefined }]);
+            }
+        }
+        else if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
+            const fn = functionOperand(statement.expression);
+            if (fn)
+                add([fn]);
+            else if (ts.isIdentifier(statement.expression))
+                add(locals.get(statement.expression.text) ?? []);
+        }
+        else if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+            for (const specifier of statement.exportClause.elements)
+                add(locals.get((specifier.propertyName ?? specifier.name).text) ?? []);
+        }
+        else if (ts.isExpressionStatement(statement)) {
+            add(commonJsSurface(statement.expression, locals));
+        }
+    }
+    add(groupOverloads(exportedDeclarations, (d) => d.name?.text ?? 'default').map((node) => ({ node, contextual: false })));
+    return [...surface.values()];
+}
+function commonJsSurface(expression, locals) {
+    if (!ts.isBinaryExpression(expression) || expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+        return [];
+    const left = expression.left;
+    const right = expression.right;
+    const isModuleExports = (e) => ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression) && e.expression.text === 'module' && e.name.text === 'exports';
+    if (isModuleExports(left)) {
+        const fn = functionOperand(right);
+        if (fn)
+            return [fn];
+        if (ts.isClassExpression(right))
+            return classSurface(right);
+        if (ts.isObjectLiteralExpression(right)) {
+            const out = [];
+            for (const property of right.properties) {
+                if (ts.isMethodDeclaration(property))
+                    out.push({ node: property, contextual: false });
+                else if (ts.isPropertyAssignment(property)) {
+                    const value = functionOperand(property.initializer);
+                    if (value)
+                        out.push(value);
+                }
+                else if (ts.isShorthandPropertyAssignment(property))
+                    out.push(...(locals.get(property.name.text) ?? []));
+            }
+            return out;
+        }
+        return [];
+    }
+    if (ts.isPropertyAccessExpression(left) &&
+        ((ts.isIdentifier(left.expression) && left.expression.text === 'exports') || isModuleExports(left.expression))) {
+        const fn = functionOperand(right);
+        return fn ? [fn] : [];
+    }
+    return [];
+}
+function countTsSlots(sourceFile, checkedAsJs) {
+    const slots = { typed: 0, total: 0 };
+    for (const { node, contextual } of publicSurface(sourceFile)) {
+        for (const parameter of node.parameters) {
+            if (ts.isIdentifier(parameter.name) && parameter.name.text === 'this')
+                continue;
+            slots.total += 1;
+            const jsdoc = checkedAsJs && ts.getJSDocParameterTags(parameter).some((tag) => tag.typeExpression !== undefined);
+            if (parameter.type !== undefined || parameter.initializer !== undefined || contextual || jsdoc)
+                slots.typed += 1;
+        }
+    }
+    return slots;
+}
+// ---- Python -------------------------------------------------------------------------------
+/** Dotted import path parts of a module, with a leading `src` directory ignored. */
+function moduleParts(file) {
+    const relative = file.package === '.' ? file.path : file.path.slice(file.package.length + 1);
+    const parts = relative.split('/');
+    if (parts[0] === 'src' && parts.length > 1)
+        parts.shift();
+    const base = path.posix.basename(relative);
+    const stem = base.replace(/\.[^.]+$/, '');
+    parts.pop();
+    if (stem !== '__init__')
+        parts.push(stem);
+    return parts;
+}
+const isPublicName = (name) => !name.startsWith('_');
+const isPublicMethod = (name) => !name.startsWith('_') || (name.startsWith('__') && name.endsWith('__') && name.length > 4);
+const isOverload = (fn) => fn.decorators.some((d) => d === 'overload' || d.endsWith('.overload'));
+/** Overload stubs are skipped when a non-overload definition of the same name exists in the same scope. */
+function withoutOverloads(functions) {
+    const implemented = new Set(functions.filter((f) => !isOverload(f)).map((f) => f.name));
+    return functions.filter((f) => !(isOverload(f) && implemented.has(f.name)));
+}
+function countFunctionSlots(fn, isMethod, slots) {
+    let params = fn.params;
+    const isStatic = fn.decorators.includes('staticmethod');
+    const first = params[0];
+    if (isMethod && (!isStatic || fn.name === '__new__') && first?.kind === 'positional')
+        params = params.slice(1);
+    for (const param of params) {
+        slots.total += 1;
+        if (param.typed)
+            slots.typed += 1;
+    }
+    if (fn.name !== '__init__') {
+        slots.total += 1;
+        if (fn.returns)
+            slots.typed += 1;
+    }
+}
+function countPythonSlots(defs, allNames) {
+    const slots = { typed: 0, total: 0 };
+    const listed = allNames === null ? null : new Set(allNames);
+    const isPublicModuleName = (name) => (listed === null ? isPublicName(name) : listed.has(name));
+    const functions = withoutOverloads(defs.filter((d) => d.kind === 'function').map((d) => d.info));
+    for (const fn of functions)
+        if (isPublicModuleName(fn.name))
+            countFunctionSlots(fn, false, slots);
+    for (const def of defs) {
+        if (def.kind !== 'class' || !isPublicModuleName(def.name))
+            continue;
+        for (const method of withoutOverloads(def.methods))
+            if (isPublicMethod(method.name))
+                countFunctionSlots(method, true, slots);
+    }
+    return slots;
+}
+// ---- Measurer -------------------------------------------------------------------------------
+export const p24 = {
+    id: '2.4',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const tsFiles = logicFiles(scope, 'typescript_javascript');
+        const pyFiles = logicFiles(scope, 'python');
+        const tallies = emptyTallies([...tsFiles, ...pyFiles]);
+        const cache = new Map();
+        const unitConfigsByPackage = new Map();
+        const configsFor = (pkg) => {
+            const existing = unitConfigsByPackage.get(pkg);
+            if (existing)
+                return existing;
+            const made = unitConfigs(repoPath, pkg, tsFiles.filter((f) => f.package === pkg).map((f) => f.path), cache);
+            unitConfigsByPackage.set(pkg, made);
+            return made;
+        };
+        for (const file of tsFiles) {
+            const tally = tallies.get(unitId(file));
+            if (!tally)
+                continue;
+            const sourceFile = scope.getTsSourceFile(file.path);
+            let checkedAsJs = false;
+            if (file.language === 'javascript') {
+                const absolute = path.resolve(repoPath, file.path).split(path.sep).join('/');
+                const byConfig = configsFor(file.package).configs.some((c) => c.options.checkJs === true && c.fileNames.has(absolute));
+                const byComment = hasLeadingDirective(sourceFile, 'ts-check') && !hasLeadingDirective(sourceFile, 'ts-nocheck');
+                checkedAsJs = byConfig || byComment;
+            }
+            const slots = countTsSlots(sourceFile, checkedAsJs);
+            tally.numerator += slots.typed;
+            tally.denominator += slots.total;
+        }
+        // Files that cannot be parsed are reported once, by 2.3.
+        const info = analyzePythonTyping(repoPath, pyFiles.map((f) => f.path));
+        for (const file of pyFiles) {
+            const tally = tallies.get(unitId(file));
+            const facts = info[file.path];
+            if (!tally || !facts?.ok)
+                continue;
+            if (moduleParts(file).some((part) => part.startsWith('_')))
+                continue;
+            const slots = countPythonSlots(facts.defs, facts.allNames);
+            tally.numerator += slots.typed;
+            tally.denominator += slots.total;
+        }
+        const units = [...tallies.values()]
+            .sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group))
+            .map((t) => ({
+            package: t.package,
+            group: t.group,
+            weight: t.weight,
+            raw: { kind: 'ratio', numerator: t.numerator, denominator: t.denominator, scale: 100 },
+        }));
+        return { status: 'measured', units };
+    },
+};

package/dist/measure/p2-5.js

@@ -0,0 +1,8 @@
+import { measureFindings } from '../exec/findings.js';
+export const p25 = {
+    id: '2.5',
+    layer: 'execution',
+    async measure(ctx) {
+        return measureFindings(ctx, (exec) => exec.lint);
+    },
+};

package/dist/measure/p3-1.js

@@ -0,0 +1,16 @@
+import { d3Gap, getD3Rules } from './d3/index.js';
+export const p31 = {
+    id: '3.1',
+    layer: 'static',
+    async measure(ctx) {
+        const gap = d3Gap(ctx);
+        if (gap !== undefined)
+            return { status: 'not_measured', reason: gap };
+        const { units, warnings } = await getD3Rules(ctx);
+        return {
+            status: 'measured',
+            units: units.map((unit) => ({ package: unit.package, group: unit.group, weight: unit.weight, raw: { kind: 'level', level: unit.level31 } })),
+            ...(warnings.length === 0 ? {} : { warnings: warnings.map((w) => `3.1: ${w}`) }),
+        };
+    },
+};