supercov 0.0.44 → 0.0.45

package/analyzers/typescript/dist/native-frontend.js

@@ -1,271 +0,0 @@
-import { createRequire, isBuiltin } from "node:module";
-import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { analysisPath } from "./compiler.js";
-import { selectedRootFiles, } from "./frontend.js";
-export function nativeFrontend(entry, projectRoot) {
-    const [major, minor] = process.versions.node.split(".").map(Number);
-    if (major < 22 || (major === 22 && minor < 12))
-        throw new Error("The TypeScript 7 frontend requires Node 22.12 or newer (Node 24 is tested)");
-    const require = createRequire(pathToFileURL(entry));
-    const ast = require("typescript/unstable/ast");
-    const native = require("typescript/unstable/sync");
-    const root = analysisPath(projectRoot);
-    const key = (file) => analysisPath(file).replaceAll("\\", "/");
-    const virtual = new Map();
-    let parseSerial = 0;
-    const opened = new Set();
-    const limitations = new Set();
-    let api;
-    let snapshot;
-    let closed = false;
-    function client() {
-        if (closed)
-            throw new Error("TypeScript 7 frontend is closed");
-        return (api ??= new native.API({
-            cwd: root,
-            fs: {
-                readFile: (file) => virtual.get(key(file)),
-                fileExists: (file) => virtual.has(key(file)) ? true : undefined,
-            },
-        }));
-    }
-    function update(config) {
-        const previous = snapshot;
-        snapshot = client().updateSnapshot({
-            ...(!opened.has(config) ? { openProjects: [config] } : {}),
-            fileChanges: { invalidateAll: true },
-        });
-        opened.add(config);
-        previous?.dispose();
-        const project = snapshot.getProject(config);
-        if (!project)
-            throw new Error(`TypeScript 7 did not open the analysis project: ${config}`);
-        return project;
-    }
-    function overlayConfig(path, config) {
-        if (existsSync(path))
-            throw new Error(`Reserved analysis config already exists: ${path}`);
-        virtual.set(key(path), JSON.stringify(config));
-    }
-    const kinds = ast.SyntaxKind;
-    const functionKinds = new Set([
-        "FunctionDeclaration",
-        "MethodDeclaration",
-        "Constructor",
-        "GetAccessor",
-        "SetAccessor",
-        "FunctionExpression",
-        "ArrowFunction",
-        "MethodSignature",
-        "CallSignature",
-        "JSDocSignature",
-        "ConstructSignature",
-        "IndexSignature",
-        "FunctionType",
-        "JSDocFunctionType",
-        "ConstructorType",
-    ]
-        .map((name) => kinds[name])
-        .filter((value) => typeof value === "number"));
-    const loopKinds = new Set([
-        "ForStatement",
-        "ForInStatement",
-        "ForOfStatement",
-        "WhileStatement",
-        "DoStatement",
-    ].map((name) => kinds[name]));
-    // These adapters preserve native nodes and native enum values. No TS5 predicate
-    // may inspect a TS7 node: syntax-kind numeric values are different.
-    const syntax = {
-        ...ast,
-        SymbolFlags: native.SymbolFlags,
-        forEachChild: (node, visit, visitArray) => node.forEachChild(visit, visitArray),
-        isFunctionLike: (node) => !!node && functionKinds.has(node.kind),
-        isIterationStatement: (node, lookInLabeledStatements) => !!node &&
-            (loopKinds.has(node.kind) ||
-                (lookInLabeledStatements &&
-                    node.kind === kinds.LabeledStatement &&
-                    syntax.isIterationStatement(node.statement, true))),
-        isMethodSignature: ast.isMethodSignatureDeclaration,
-        isParameter: ast.isParameterDeclaration,
-        isTypeAssertionExpression: ast.isTypeAssertion,
-        isStringLiteralLike: (node) => !!node &&
-            (node.kind === kinds.StringLiteral ||
-                node.kind === kinds.NoSubstitutionTemplateLiteral),
-        canHaveModifiers: (node) => !!node && "modifiers" in node,
-        getModifiers: (node) => node.modifiers?.filter((m) => m.kind !== kinds.Decorator),
-    };
-    for (const name of [
-        "isMethodSignature",
-        "isParameter",
-        "isTypeAssertionExpression",
-        "getLeadingCommentRanges",
-        "getTrailingCommentRanges",
-    ])
-        if (typeof syntax[name] !== "function")
-            throw new Error(`Unsupported TypeScript 7 syntax API: ${name}`);
-    const frontend = {
-        kind: "typescript-native-7",
-        version: "7.0.2",
-        syntax,
-        limitations,
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            try {
-                snapshot?.dispose();
-            }
-            finally {
-                api?.close();
-            }
-        },
-        parseSource(file, text) {
-            const absolute = resolve(root, file);
-            virtual.set(key(absolute), text);
-            // Do not rely on 7.0.2 reloading an edited virtual config's root-file list.
-            const parseConfig = resolve(root, `.supercov-asserted-parse-${++parseSerial}.tsconfig.json`);
-            overlayConfig(parseConfig, {
-                files: [absolute],
-                compilerOptions: {
-                    allowJs: true,
-                    checkJs: true,
-                    noResolve: true,
-                    noLib: true,
-                    noEmit: true,
-                    types: [],
-                },
-            });
-            const project = update(parseConfig);
-            const source = project.program.getSourceFile(absolute);
-            if (!source || source.text !== text)
-                throw new Error(`Native parser source mismatch: ${file}`);
-            const errors = project.program.getSyntacticDiagnostics(absolute);
-            if (errors.length)
-                throw new Error(`Native parser rejected ${file}: ${JSON.stringify(errors)}`);
-            return source;
-        },
-        openProgram(options) {
-            const configPath = resolve(root, options.tsconfig ?? "tsconfig.json");
-            const hasConfig = existsSync(configPath);
-            if (!hasConfig && !options.sourceFiles)
-                throw new Error(`Missing TypeScript config: ${configPath}`);
-            const configured = hasConfig
-                ? client().parseConfigFile(configPath).fileNames
-                : [];
-            const files = selectedRootFiles(options, configured);
-            const overlay = resolve(dirname(configPath), ".supercov-asserted-query.tsconfig.json");
-            overlayConfig(overlay, {
-                ...(hasConfig ? { extends: configPath } : {}),
-                files,
-                include: [],
-                exclude: [],
-                compilerOptions: {
-                    ...(options.sourceFiles ? { allowJs: true, checkJs: true } : {}),
-                    noEmit: true,
-                },
-            });
-            const project = update(overlay);
-            const program = project.program;
-            const configErrors = program.getConfigFileParsingDiagnostics();
-            if (configErrors.length)
-                throw new Error(`TypeScript 7 configuration is invalid: ${JSON.stringify(configErrors)}`);
-            const checker = project.checker;
-            const symbols = new WeakMap();
-            const nativeSymbols = new WeakMap();
-            function wrapSymbol(symbol) {
-                if (!symbol)
-                    return undefined;
-                let wrapped = symbols.get(symbol);
-                if (!wrapped) {
-                    wrapped = {
-                        flags: symbol.flags,
-                        name: symbol.name,
-                        escapedName: symbol.escapedName,
-                        get valueDeclaration() {
-                            return symbol.valueDeclaration?.resolve(project);
-                        },
-                        get declarations() {
-                            return symbol.declarations.map((handle) => {
-                                const node = handle.resolve(project);
-                                if (!node)
-                                    throw new Error("TypeScript 7 declaration handle did not resolve");
-                                return node;
-                            });
-                        },
-                    };
-                    symbols.set(symbol, wrapped);
-                    nativeSymbols.set(wrapped, symbol);
-                }
-                return wrapped;
-            }
-            const allFiles = program
-                .getSourceFileNames()
-                .map((file) => {
-                const source = program.getSourceFile(file);
-                if (!source)
-                    throw new Error(`Native source disappeared: ${file}`);
-                return source;
-            });
-            const resolutionCache = new Map();
-            return {
-                files: allFiles,
-                checker: {
-                    getSymbolAtLocation: (node) => wrapSymbol(checker.getSymbolAtLocation(node)),
-                    getShorthandAssignmentValueSymbol: (node) => wrapSymbol(checker.getShorthandAssignmentValueSymbol(node)),
-                    getAliasedSymbol: (symbol) => {
-                        const original = nativeSymbols.get(symbol);
-                        if (!original)
-                            throw new Error("Symbol belongs to a different compiler session");
-                        return wrapSymbol(checker.getAliasedSymbol(original));
-                    },
-                    getResolvedSignature: (node) => {
-                        const signature = checker.getResolvedSignature(node);
-                        return signature
-                            ? {
-                                getParameters: () => signature.getParameters().map(wrapSymbol),
-                            }
-                            : undefined;
-                    },
-                },
-                resolveModule(specifier, from) {
-                    const cacheKey = `${key(from)}\0${specifier}`;
-                    if (resolutionCache.has(cacheKey))
-                        return resolutionCache.get(cacheKey);
-                    const source = program.getSourceFile(from);
-                    const paths = new Set();
-                    const visit = (node) => {
-                        if (syntax.isStringLiteralLike(node) && node.text === specifier) {
-                            // Ask the native checker about actual module-reference syntax. A
-                            // vi.mock string is not a TypeScript import and is not guessed.
-                            const p = node.parent;
-                            if (p &&
-                                (ast.isImportDeclaration(p) ||
-                                    ast.isExportDeclaration(p) ||
-                                    (ast.isCallExpression(p) &&
-                                        p.expression.kind === kinds.ImportKeyword))) {
-                                const symbol = checker.getSymbolAtLocation(node);
-                                for (const handle of symbol?.declarations ?? []) {
-                                    const declaration = handle.resolve(project);
-                                    if (declaration && syntax.isSourceFile(declaration))
-                                        paths.add(declaration.fileName);
-                                }
-                            }
-                        }
-                        node.forEachChild(visit);
-                    };
-                    if (source)
-                        visit(source);
-                    const result = paths.size === 1 ? [...paths][0] : undefined;
-                    if (!result && !isBuiltin(specifier))
-                        limitations.add(`native-module-resolution: ${key(from)} → ${specifier}`);
-                    resolutionCache.set(cacheKey, result);
-                    return result;
-                },
-            };
-        },
-    };
-    return frontend;
-}

package/analyzers/typescript/dist/pragmas.js

@@ -1,186 +0,0 @@
-export function assertionWitnessIssue(phases, source, method) {
-    const matches = (phases ?? []).filter((p) => p.source === source && p.op.split(".").pop() === method);
-    if (source && matches.length && matches.every((p) => p.status === "passed"))
-        return undefined;
-    const statuses = new Set(matches.map((p) => p.status ?? "unknown"));
-    return !phases
-        ? "capture-unavailable"
-        : !source
-            ? "uninstrumented-observation"
-            : !matches.length
-                ? "call-not-recorded"
-                : statuses.size > 1
-                    ? "mixed-call-outcomes"
-                    : statuses.has("failed")
-                        ? "call-failed"
-                        : "call-incomplete";
-}
-/** Source hints are kept OUT of observations. A comment never adds a boundary. */
-export function collectPragmas(compiler, files, relativeFile, sites) {
-    const comments = new Map();
-    const key = (sf, pos) => `${relativeFile(sf)}:${pos}`;
-    const location = (sf, pos) => {
-        const p = sf.getLineAndCharacterOfPosition(pos);
-        return `${relativeFile(sf)}:${p.line + 1}:${p.character + 1}`;
-    };
-    for (const sf of files) {
-        const collect = (ranges) => {
-            for (const range of ranges ?? []) {
-                const raw = sf.text.slice(range.pos, range.end);
-                if (!/^\/\/\s*observes:/.test(raw) || comments.has(key(sf, range.pos)))
-                    continue;
-                const parts = raw.split(/;\s*check\s+/);
-                const check = parts.length === 2 && parts[1].trim() === "missing call"
-                    ? "missing-call"
-                    : parts.length === 2 && parts[1].trim() === "count"
-                        ? "count"
-                        : parts.length === 2 && parts[1].trim() === "value"
-                            ? "value"
-                            : parts.length === 2 && parts[1].trim() === "completion"
-                                ? "completion"
-                                : undefined;
-                const checkIssue = parts.length > 1 && !check ? "unsupported-check-recipe" : undefined;
-                const parsed = /^\/\/\s*observes:\s*(\S+?)#(\S+)(?:\s+(.+?))?\s*$/.exec(parts[0]);
-                const suffix = parsed?.[3]?.split(/(?:^|\s+)via\s+/);
-                const target = parsed
-                    ? {
-                        file: parsed[1],
-                        function: parsed[2],
-                        snippet: suffix?.[0]?.trim() || undefined,
-                        via: suffix?.slice(1).join(" via ").trim() || undefined,
-                    }
-                    : undefined;
-                const validPath = target &&
-                    !/[\\:]/.test(target.file) &&
-                    target.file
-                        .split("/")
-                        .every((part) => part && part !== "." && part !== "..");
-                const matchingSites = validPath
-                    ? sites.filter((s) => s.file === target.file &&
-                        // The recipe selects the emission, not a containing callback-return site.
-                        (!check ||
-                            (check === "missing-call"
-                                ? s.category === "log"
-                                : check === "completion"
-                                    ? s.category === "return" || s.category === "throw"
-                                    : s.kind === "decision" || s.category === "return")) &&
-                        (s.owner === target.function || s.fn === target.function) &&
-                        (!target.snippet || s.text.includes(target.snippet)))
-                    : [];
-                // An exact whole-site selector is more specific than a containing return
-                // whose display text happens to include that expression. Equal sibling
-                // sites remain ambiguous. This only selects a node; it proves no behavior.
-                const exact = check && target?.snippet
-                    ? matchingSites.filter((s) => s.text.trim() === target.snippet.trim())
-                    : [];
-                const candidates = (exact.length ? exact : matchingSites).map((s) => s.id);
-                comments.set(key(sf, range.pos), {
-                    id: location(sf, range.pos),
-                    where: location(sf, range.pos),
-                    raw,
-                    target,
-                    ...(check ? { check } : {}),
-                    candidateSites: candidates,
-                    issue: checkIssue ??
-                        (!target
-                            ? "invalid-syntax"
-                            : !validPath
-                                ? "invalid-target-path"
-                                : !candidates.length
-                                    ? "target-not-in-inventory"
-                                    : candidates.length > 1
-                                        ? "ambiguous-target"
-                                        : undefined),
-                    attachments: [],
-                });
-            }
-        };
-        const visit = (node) => {
-            collect(compiler.getLeadingCommentRanges(sf.text, node.getFullStart()));
-            collect(compiler.getTrailingCommentRanges(sf.text, node.getEnd()));
-            compiler.forEachChild(node, visit);
-        };
-        visit(sf);
-    }
-    return {
-        hasHint(node) {
-            let statement = node;
-            while (statement.parent && !compiler.isStatement(statement))
-                statement = statement.parent;
-            if (!compiler.isExpressionStatement(statement))
-                return false;
-            const sf = node.getSourceFile();
-            return (compiler.getLeadingCommentRanges(sf.text, statement.getFullStart()) ??
-                []).some((range) => comments.has(key(sf, range.pos)));
-        },
-        register(node, method, testKey, inert, awaitedObservation) {
-            let statement = node;
-            while (statement.parent && !compiler.isStatement(statement))
-                statement = statement.parent;
-            // A comment on an if/block/declaration is not a claim about every assertion inside it.
-            if (!compiler.isExpressionStatement(statement))
-                return;
-            const sf = node.getSourceFile();
-            for (const range of compiler.getLeadingCommentRanges(sf.text, statement.getFullStart()) ?? []) {
-                const comment = comments.get(key(sf, range.pos));
-                if (!comment)
-                    continue;
-                const attachment = {
-                    testKey,
-                    source: location(sf, node.getStart(sf)),
-                    method,
-                    inert,
-                    ...(awaitedObservation ? { awaitedObservation } : {}),
-                };
-                if (!comment.attachments.some((a) => a.testKey === testKey &&
-                    a.source === attachment.source &&
-                    a.method === method))
-                    comment.attachments.push(attachment);
-            }
-        },
-        finish(bindings) {
-            return [...comments.values()].flatMap(({ attachments, ...comment }) => {
-                const sources = new Set(attachments.map((a) => `${a.source}#${a.method}`));
-                const issue = comment.issue ??
-                    (sources.size > 1
-                        ? "ambiguous-assertion"
-                        : !sources.size
-                            ? "unattached-assertion"
-                            : undefined);
-                const matched = bindings.flatMap((b) => attachments
-                    .filter((a) => a.testKey === b.testKey && !a.inert)
-                    .map((a) => ({ a, b })));
-                if (sources.size !== 1 || !matched.length)
-                    return [
-                        {
-                            ...comment,
-                            issue: issue ?? "no-owning-passed-test",
-                            witness: "unavailable",
-                        },
-                    ];
-                return matched.map(({ a, b }) => {
-                    // A source-checked poll is not an explicit assertion phase. Neither
-                    // a matching phase name nor a passing test can supply its read receipt.
-                    const witnessIssue = a.awaitedObservation
-                        ? "observation-capture-unavailable"
-                        : assertionWitnessIssue(b.phases, a.source, a.method);
-                    return {
-                        ...comment,
-                        id: `${comment.id}@${b.id}`,
-                        issue,
-                        test: b.id,
-                        assertionSource: a.source,
-                        assertionMethod: a.method,
-                        ...(a.awaitedObservation
-                            ? { awaitedObservation: a.awaitedObservation }
-                            : {}),
-                        witness: witnessIssue
-                            ? "unavailable"
-                            : "passed",
-                        witnessIssue,
-                    };
-                });
-            });
-        },
-    };
-}

package/analyzers/typescript/dist/types.js

@@ -1 +0,0 @@
-export {};

package/analyzers/typescript/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "@supercov/asserted-typescript",
-  "version": "0.0.0",
-  "private": true,
-  "description": "TypeScript assertion and value-flow facts for Supercov's language-neutral join",
-  "type": "module",
-  "engines": {
-    "node": ">=22"
-  },
-  "files": [
-    "dist",
-    "bin",
-    "src",
-    "tsconfig.json",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "node node_modules/typescript/bin/tsc -p tsconfig.json && node bin/identity.mjs",
-    "test": "npm run build && node --test tests/*.test.mjs",
-    "prepack": "npm run build"
-  },
-  "devDependencies": {
-    "@types/node": "24.0.0",
-    "typescript": "5.8.3",
-    "typescript-native": "npm:typescript@7.0.2"
-  }
-}