supercov 0.0.43 → 0.0.44

package/analyzers/typescript/dist/archive.js

@@ -10,7 +10,24 @@ export const PROTOCOL = {
     capabilities: [
         "requiresTotal-v1",
         "assertion-witness-issues-v1",
+        "complete-passed-test-inventory-v1",
+        "witnessed-callback-scope-v1",
         "assertion-hints-v1",
+        "awaited-observation-sources-v1",
+        "first-test-call-omission-v1",
+        "closed-count-sensitivity-v1",
+        "closed-payload-sensitivity-v1",
+        "payload-native-predicates-v1",
+        "first-test-direct-return-v1",
+        "mock-observation-projections-v1",
+        "assertion-comparison-relations-v2",
+        "process-exit-source-v1",
+        "process-exit-consumer-v1",
+        "mock-count-lifetimes-v1",
+        "mock-count-factories-v1",
+        "mock-count-rows-v1",
+        "mock-count-array-projections-v1",
+        "primitive-decision-sensitivity-v1",
     ],
 };
 function sameScope(a, b) {
@@ -122,13 +139,22 @@ function analyzeArchiveWithFrontend(input, frontend) {
             throw new Error(`Unsupported decision atom layout: ${d.id}`);
         atoms.forEach((n, i) => {
             const begin = sf.getLineAndCharacterOfPosition(n.getStart(sf)), end = sf.getLineAndCharacterOfPosition(n.getEnd());
-            // The flow pass resolves the actual AST owner; this fallback is only for presentation.
+            // This owner also participates in source-hint selection. Named arrow
+            // bindings must not be mislabeled <module> merely because they are not
+            // function declarations.
             let parent = n.parent, owner = "<module>";
             while (parent) {
                 if (compiler.isFunctionDeclaration(parent) && parent.name) {
                     owner = parent.name.text;
                     break;
                 }
+                if ((compiler.isArrowFunction(parent) ||
+                    compiler.isFunctionExpression(parent)) &&
+                    compiler.isVariableDeclaration(parent.parent) &&
+                    compiler.isIdentifier(parent.parent.name)) {
+                    owner = parent.parent.name.text;
+                    break;
+                }
                 parent = parent.parent;
             }
             sites.push({
@@ -181,8 +207,9 @@ function analyzeArchiveWithFrontend(input, frontend) {
     for (const [i, r] of accepted.entries()) {
         const id = `A${i + 1}`;
         if (!r.testFile) {
-            limitations.add("A passed test has no source file.");
-            continue;
+            // Dropping even one passing attempt could turn its executed/asserted sites
+            // into apparently certain gaps. Ordinary coverage can still be queried.
+            throw new Error("A passed test has no source file; assertion analysis requires test-source provenance. Recapture with a supported runner and stack formatter.");
         }
         if (r.browser.length)
             limitations.add("Browser evidence is not joined in this archive adapter.");
@@ -272,6 +299,7 @@ function analyzeArchiveWithFrontend(input, frontend) {
             line: 0,
             ok: true,
             phaseLines,
+            runner: r.provenance?.runner,
         });
         attempts.push({
             id,

package/analyzers/typescript/dist/awaited-observations.js

@@ -0,0 +1,376 @@
+/**
+ * Recognize a direct awaited factory method which polls an append-only native
+ * child capture. Names, paths, regex and timeout values come from bindings/source.
+ * Unsupported control flow or aliases are not evidence of a missing assertion.
+ * Native APIs and absence of external monkey-patching remain model premises.
+ */
+export function awaitedObservationSource(context, callback, call) {
+    const { syntax: t, declaration: decl, rawDeclaration: raw } = context;
+    function require(value) {
+        if (!value)
+            throw unsupported;
+    }
+    const unsupported = Symbol("unsupported awaited observation");
+    const nodes = (root, predicate) => {
+        const found = [];
+        const visit = (n) => {
+            if (predicate(n))
+                found.push(n);
+            t.forEachChild(n, visit);
+        };
+        visit(root);
+        return found;
+    };
+    const one = (values) => {
+        require(values.length === 1);
+        return values[0];
+    };
+    const at = (node) => {
+        const sf = node.getSourceFile(), p = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+        return `${context.relativeFile(sf)}:${p.line + 1}:${p.character + 1}`;
+    };
+    const importedFrom = (node, name) => {
+        const d = raw(node);
+        return !!d &&
+            t.isImportSpecifier(d) &&
+            !d.isTypeOnly &&
+            !d.parent.parent.isTypeOnly &&
+            (d.propertyName ?? d.name).text === name &&
+            t.isStringLiteral(d.parent.parent.parent.moduleSpecifier)
+            ? d.parent.parent.parent.moduleSpecifier.text
+            : undefined;
+    };
+    const constant = (node) => t.isVariableDeclaration(node) &&
+        t.isIdentifier(node.name) &&
+        t.isVariableDeclarationList(node.parent) &&
+        !!(node.parent.flags & t.NodeFlags.Const) &&
+        node.parent.declarations.length === 1;
+    const simpleArrow = (node) => t.isArrowFunction(node) &&
+        node.parameters.length === 0 &&
+        !node.modifiers?.length;
+    const bodyExpression = (node) => {
+        if (!t.isBlock(node.body))
+            return node.body;
+        require(node.body.statements.length === 1);
+        const returned = node.body.statements[0];
+        require(t.isReturnStatement(returned) && returned.expression);
+        return returned.expression;
+    };
+    const positiveNumber = (node) => t.isNumericLiteral(node) &&
+        Number.isFinite(Number(node.text)) &&
+        Number(node.text) > 0;
+    const global = (node, name) => {
+        const d = decl(node);
+        return (t.isIdentifier(node) &&
+            node.text === name &&
+            (!d || d.getSourceFile().isDeclarationFile));
+    };
+    const dateNow = (node) => t.isCallExpression(node) &&
+        !node.questionDotToken &&
+        node.arguments.length === 0 &&
+        t.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === "now" &&
+        global(node.expression.expression, "Date");
+    const references = (root, binding) => nodes(root, (n) => t.isIdentifier(n) && decl(n) === binding);
+    try {
+        require(t.isArrowFunction(callback) &&
+            t.isBlock(callback.body) &&
+            callback.modifiers?.some((m) => m.kind === t.SyntaxKind.AsyncKeyword));
+        const registration = callback.parent;
+        require(t.isCallExpression(registration) &&
+            registration.arguments.at(-1) === callback &&
+            importedFrom(registration.expression, "test") === "node:test" &&
+            t.isExpressionStatement(registration.parent) &&
+            t.isSourceFile(registration.parent.parent));
+        require(callback.body.statements.every((s) => t.isVariableStatement(s) || t.isExpressionStatement(s)));
+        require(t.isAwaitExpression(call.parent) &&
+            t.isExpressionStatement(call.parent.parent) &&
+            call.parent.parent.parent === callback.body &&
+            call.arguments.length === 0 &&
+            !call.questionDotToken &&
+            t.isPropertyAccessExpression(call.expression) &&
+            !call.expression.questionDotToken);
+        const member = call.expression.name.text, receiver = decl(call.expression.expression);
+        require(receiver &&
+            constant(receiver) &&
+            receiver.initializer &&
+            t.isCallExpression(receiver.initializer));
+        const launch = receiver.initializer, factory = decl(launch.expression);
+        require(factory &&
+            t.isFunctionDeclaration(factory) &&
+            factory.body &&
+            !factory.asteriskToken &&
+            !factory.modifiers?.some((m) => m.kind === t.SyntaxKind.AsyncKeyword) &&
+            factory.parameters.every((p) => t.isIdentifier(p.name) && !p.initializer && !p.dotDotDotToken));
+        require(receiver.parent.parent.parent === callback.body);
+        const statements = callback.body.statements;
+        require(statements.indexOf(call.parent.parent) ===
+            statements.indexOf(receiver.parent.parent) + 1);
+        require(nodes(callback, (n) => t.isCallExpression(n) && decl(n.expression) === factory).length === 1);
+        require(nodes(callback, (n) => t.isCallExpression(n) &&
+            t.isPropertyAccessExpression(n.expression) &&
+            decl(n.expression.expression) === receiver &&
+            n.expression.name.text === member).length === 1);
+        require(nodes(callback, (n) => t.isIdentifier(n) && ["eval", "Function"].includes(n.text)).length === 0);
+        const factoryBody = factory.body;
+        require(factoryBody.statements.every((s) => t.isVariableStatement(s) ||
+            t.isExpressionStatement(s) ||
+            t.isReturnStatement(s)));
+        const returned = one(factoryBody.statements.filter(t.isReturnStatement));
+        require(returned === factoryBody.statements.at(-1) &&
+            returned.expression &&
+            t.isObjectLiteralExpression(returned.expression));
+        const members = returned.expression.properties;
+        require(members.every((p) => (t.isPropertyAssignment(p) || t.isShorthandPropertyAssignment(p)) &&
+            t.isIdentifier(p.name)));
+        require(new Set(members.map((p) => p.name.getText())).size === members.length);
+        const property = one(members.filter((p) => p.name?.getText() === member));
+        require(t.isPropertyAssignment(property) && simpleArrow(property.initializer));
+        const pollCall = bodyExpression(property.initializer);
+        require(t.isCallExpression(pollCall) &&
+            !pollCall.questionDotToken &&
+            pollCall.arguments.length >= 1);
+        const poll = decl(pollCall.expression);
+        require(poll &&
+            constant(poll) &&
+            poll.parent.parent.parent === factoryBody &&
+            poll.initializer &&
+            t.isArrowFunction(poll.initializer) &&
+            t.isBlock(poll.initializer.body) &&
+            poll.initializer.modifiers?.some((m) => m.kind === t.SyntaxKind.AsyncKeyword));
+        const pollFn = poll.initializer, pollBody = pollFn.body;
+        require(pollFn.parameters.length === pollCall.arguments.length &&
+            pollFn.parameters.every((p) => t.isIdentifier(p.name) && !p.initializer && !p.dotDotDotToken));
+        require(pollBody.statements.length === 2 &&
+            t.isVariableStatement(pollBody.statements[0]));
+        const deadline = one(pollBody.statements[0].declarationList.declarations);
+        require(constant(deadline) &&
+            deadline.initializer &&
+            t.isBinaryExpression(deadline.initializer) &&
+            deadline.initializer.operatorToken.kind === t.SyntaxKind.PlusToken &&
+            dateNow(deadline.initializer.left) &&
+            positiveNumber(deadline.initializer.right));
+        const loop = pollBody.statements[1];
+        require(t.isWhileStatement(loop) &&
+            t.isPrefixUnaryExpression(loop.expression) &&
+            loop.expression.operator === t.SyntaxKind.ExclamationToken &&
+            t.isCallExpression(loop.expression.operand));
+        const predicateCall = loop.expression.operand;
+        require(predicateCall.arguments.length === 0 &&
+            decl(predicateCall.expression) === pollFn.parameters[0] &&
+            !predicateCall.questionDotToken &&
+            t.isBlock(loop.statement) &&
+            loop.statement.statements.length === 2);
+        require(references(pollFn, pollFn.parameters[0]).every((n) => n === pollFn.parameters[0].name || n === predicateCall.expression));
+        const [guard, pause] = loop.statement.statements;
+        require(t.isIfStatement(guard) &&
+            !guard.elseStatement &&
+            t.isBlock(guard.thenStatement) &&
+            guard.thenStatement.statements.length === 1 &&
+            t.isThrowStatement(guard.thenStatement.statements[0]));
+        require(t.isExpressionStatement(pause) &&
+            t.isAwaitExpression(pause.expression) &&
+            t.isCallExpression(pause.expression.expression));
+        const delay = pause.expression.expression;
+        require(importedFrom(delay.expression, "setTimeout") === "node:timers/promises" &&
+            !delay.questionDotToken &&
+            delay.arguments.length === 1 &&
+            positiveNumber(delay.arguments[0]));
+        const predicate = pollCall.arguments[0];
+        require(simpleArrow(predicate));
+        const read = bodyExpression(predicate);
+        require(t.isCallExpression(read) &&
+            !read.questionDotToken &&
+            read.arguments.length === 1 &&
+            t.isPropertyAccessExpression(read.expression) &&
+            read.expression.name.text === "test" &&
+            t.isRegularExpressionLiteral(read.expression.expression));
+        const regex = read.expression.expression.text;
+        require(!/[gy]/.test(regex.slice(regex.lastIndexOf("/") + 1)));
+        const input = read.arguments[0];
+        const operands = t.isBinaryExpression(input) &&
+            input.operatorToken.kind === t.SyntaxKind.PlusToken
+            ? [input.left, input.right]
+            : [input];
+        const buffers = operands.map((o) => decl(o));
+        require(buffers.every((b) => b && t.isVariableDeclaration(b)) &&
+            new Set(buffers).size === buffers.length);
+        let child;
+        const captures = [];
+        for (const [index, maybeBuffer] of buffers.entries()) {
+            const buffer = maybeBuffer;
+            require(buffer.parent.parent.parent === factoryBody &&
+                t.isVariableDeclarationList(buffer.parent) &&
+                !!(buffer.parent.flags & t.NodeFlags.Let) &&
+                t.isIdentifier(buffer.name) &&
+                buffer.initializer &&
+                t.isStringLiteral(buffer.initializer) &&
+                buffer.initializer.text === "");
+            const append = one(nodes(factoryBody, (n) => t.isBinaryExpression(n) &&
+                decl(n.left) === buffer &&
+                n.operatorToken.kind >= t.SyntaxKind.FirstAssignment &&
+                n.operatorToken.kind <= t.SyntaxKind.LastAssignment));
+            require(t.isBinaryExpression(append) &&
+                append.operatorToken.kind === t.SyntaxKind.PlusEqualsToken &&
+                t.isExpressionStatement(append.parent) &&
+                t.isBlock(append.parent.parent));
+            const capture = append.parent.parent.parent;
+            require(t.isArrowFunction(capture) &&
+                !capture.modifiers?.length &&
+                capture.parameters.length === 1 &&
+                !capture.parameters[0].initializer &&
+                !capture.parameters[0].dotDotDotToken &&
+                decl(append.right) === capture.parameters[0] &&
+                t.isBlock(capture.body) &&
+                capture.body.statements.length === 1);
+            const on = capture.parent;
+            require(t.isCallExpression(on) &&
+                on.arguments.length === 2 &&
+                on.arguments[1] === capture &&
+                !on.questionDotToken &&
+                t.isStringLiteral(on.arguments[0]) &&
+                on.arguments[0].text === "data" &&
+                t.isPropertyAccessExpression(on.expression) &&
+                !on.expression.questionDotToken &&
+                on.expression.name.text === "on" &&
+                t.isCallExpression(on.expression.expression));
+            const encoding = on.expression.expression;
+            require(!encoding.questionDotToken &&
+                encoding.arguments.length === 1 &&
+                t.isStringLiteral(encoding.arguments[0]) &&
+                encoding.arguments[0].text === "utf8" &&
+                t.isPropertyAccessExpression(encoding.expression) &&
+                encoding.expression.name.text === "setEncoding" &&
+                !encoding.expression.questionDotToken &&
+                t.isPropertyAccessExpression(encoding.expression.expression));
+            const stream = encoding.expression.expression;
+            require(!stream.questionDotToken &&
+                (stream.name.text === "stdout" || stream.name.text === "stderr"));
+            const streamChild = decl(stream.expression);
+            require(streamChild &&
+                constant(streamChild) &&
+                (!child || child === streamChild));
+            child = streamChild;
+            require(t.isExpressionStatement(on.parent) && on.parent.parent === factoryBody);
+            // Only initialization, append, the predicate, trivial accessors and the
+            // throw diagnostic can read this binding. No transformed/escaped capture.
+            const allowed = new Set([
+                buffer.name,
+                append.left,
+                operands[index],
+                ...references(guard.thenStatement, buffer),
+            ]);
+            for (const p of members)
+                if (t.isPropertyAssignment(p) && simpleArrow(p.initializer)) {
+                    const value = bodyExpression(p.initializer);
+                    if (decl(value) === buffer)
+                        allowed.add(value);
+                }
+            require(references(factoryBody, buffer).every((n) => allowed.has(n)));
+            const streamRefs = nodes(factoryBody, (n) => t.isPropertyAccessExpression(n) &&
+                decl(n.expression) === child &&
+                n.name.text === stream.name.text);
+            require(streamRefs.length === 1);
+            captures.push({ stream: stream.name.text, source: at(append) });
+        }
+        require(child &&
+            child.initializer &&
+            t.isCallExpression(child.initializer) &&
+            child.parent.parent.parent === factoryBody &&
+            importedFrom(child.initializer.expression, "spawn") ===
+                "node:child_process");
+        const spawn = child.initializer;
+        require(!spawn.questionDotToken &&
+            spawn.arguments.length === 3 &&
+            t.isObjectLiteralExpression(spawn.arguments[2]));
+        const options = spawn.arguments[2].properties;
+        require(options.every((p) => t.isPropertyAssignment(p) && t.isIdentifier(p.name)) &&
+            new Set(options.map((p) => p.name.getText())).size === options.length);
+        const stdio = one(options.filter((p) => p.name?.getText() === "stdio"));
+        require(t.isPropertyAssignment(stdio) &&
+            t.isStringLiteral(stdio.initializer) &&
+            stdio.initializer.text === "pipe");
+        for (const ref of references(factoryBody, child)) {
+            if (ref === child.name ||
+                (t.isShorthandPropertyAssignment(ref.parent) &&
+                    ref.parent.parent === returned.expression))
+                continue;
+            require(t.isPropertyAccessExpression(ref.parent) &&
+                ref.parent.expression === ref);
+            const access = ref.parent;
+            require([
+                "stdout",
+                "stderr",
+                "exitCode",
+                "signalCode",
+                "pid",
+                "once",
+                "kill",
+            ].includes(access.name.text));
+            require(!(t.isBinaryExpression(access.parent) &&
+                access.parent.left === access &&
+                access.parent.operatorToken.kind >= t.SyntaxKind.FirstAssignment &&
+                access.parent.operatorToken.kind <= t.SyntaxKind.LastAssignment) &&
+                !t.isDeleteExpression(access.parent) &&
+                !t.isPostfixUnaryExpression(access.parent) &&
+                !(t.isPrefixUnaryExpression(access.parent) &&
+                    [t.SyntaxKind.PlusPlusToken, t.SyntaxKind.MinusMinusToken].includes(access.parent.operator)));
+            if (["once", "kill"].includes(access.name.text))
+                require(t.isCallExpression(access.parent) &&
+                    access.parent.expression === access);
+        }
+        const disjuncts = (n) => t.isBinaryExpression(n) &&
+            n.operatorToken.kind === t.SyntaxKind.BarBarToken
+            ? [...disjuncts(n.left), ...disjuncts(n.right)]
+            : [n];
+        const checks = disjuncts(guard.expression);
+        require(checks.length === 3);
+        for (const [index, name] of ["exitCode", "signalCode"].entries()) {
+            const check = checks[index];
+            require(t.isBinaryExpression(check) &&
+                check.operatorToken.kind ===
+                    t.SyntaxKind.ExclamationEqualsEqualsToken &&
+                check.right.kind === t.SyntaxKind.NullKeyword &&
+                t.isPropertyAccessExpression(check.left) &&
+                check.left.name.text === name &&
+                decl(check.left.expression) === child);
+        }
+        const expired = checks[2];
+        require(t.isBinaryExpression(expired) &&
+            expired.operatorToken.kind === t.SyntaxKind.GreaterThanToken &&
+            dateNow(expired.left) &&
+            decl(expired.right) === deadline);
+        require(references(factoryBody, poll).every((n) => n === poll.name ||
+            n === pollCall.expression ||
+            (t.isShorthandPropertyAssignment(n.parent) &&
+                n.parent.parent === returned.expression)));
+        for (const ref of references(callback, receiver)) {
+            if (ref === receiver.name)
+                continue;
+            require(t.isPropertyAccessExpression(ref.parent) &&
+                ref.parent.expression === ref);
+            const use = ref.parent;
+            require(t.isCallExpression(use.parent) && use.parent.expression === use);
+            const usedProperty = one(members.filter((p) => p.name?.getText() === use.name.text));
+            require(usedProperty === property ||
+                (t.isShorthandPropertyAssignment(usedProperty) &&
+                    decl(usedProperty.name) === poll) ||
+                (t.isPropertyAssignment(usedProperty) &&
+                    simpleArrow(usedProperty.initializer) &&
+                    buffers.includes(decl(bodyExpression(usedProperty.initializer)))));
+        }
+        require(nodes(factoryBody, (n) => t.isIdentifier(n) && ["eval", "Function"].includes(n.text)).length === 0);
+        return {
+            model: "node-child-capture-poll-v1",
+            factorySource: at(factory),
+            predicateSource: at(read),
+            captures,
+            pattern: regex,
+        };
+    }
+    catch (error) {
+        if (error === unsupported)
+            return undefined;
+        throw error;
+    }
+}

package/analyzers/typescript/dist/build-identity.json

@@ -1 +1 @@
-{"schema":1,"sourceSha256":"58c5fd835878413942c6944032f3bcd0b6c76ce82fd0ae6048b0aeef4bd65612","compiledSha256":"8c2ee2f19f780465bffd589b5cff23cec80234744316a2067063318b2dc7906f"}
+{"schema":1,"sourceSha256":"b9f0ed836fd8bda03ee3793896da9769e70e9a4b56f6b8716ad683c84cf77680","compiledSha256":"80ce9da5db394e7958b1e2c67dc2b12434c539c3890e32ac6fd0f40fc509df5d"}