supercov 0.0.43 → 0.0.44

package/analyzers/typescript/dist/analyze.js

@@ -2,6 +2,8 @@ import { relative as pathRelative } from "node:path";
 import { analysisPath } from "./compiler.js";
 import { createFrontend } from "./frontend.js";
 import { assertionWitnessIssue, collectPragmas } from "./pragmas.js";
+import { awaitedObservationSource } from "./awaited-observations.js";
+import { analyzeMockCounts, analyzeFirstTestOmission, analyzeCountSensitivity, analyzePayloadSensitivity, analyzeDirectReturnSensitivity, analyzeCompletionSensitivity, sourceTestRows, } from "./mock-counts.js";
 // Archive/site/test identities use forward slashes on every host.
 const relative = (from, to) => pathRelative(from, to).replaceAll("\\", "/");
 export function analyze(options) {
@@ -1709,8 +1711,684 @@ export function analyzeWithFrontend(options, frontend) {
         doesNotReject: "presence",
     };
     const staticTests = [];
+    const mockBodies = new Map();
     const pragmaCollector = collectPragmas(ts, allFiles.filter(isTestFile), rel, sites);
     const staticTestKey = (file, line, name) => JSON.stringify([file, line, name]);
+    // Unlike origin tracing, comparison identity must NOT erase await, calls,
+    // getters or transformations. Only syntax with no runtime operation is peeled.
+    function comparisonExpression(e) {
+        while (ts.isParenthesizedExpression(e) ||
+            ts.isNonNullExpression(e) ||
+            ts.isAsExpression(e) ||
+            ts.isTypeAssertionExpression(e) ||
+            ts.isSatisfiesExpression(e))
+            e = e.expression;
+        return e;
+    }
+    /** Native import identity, not the spelling of a local helper. Bare native
+     * assert and imported ok are the same truthiness operation in the recorder.
+     * Keep this canonicalization at discovery: the witness checker must not equate
+     * arbitrary operations named assert and ok or weaken its source/status check. */
+    function nativeAssertionIdentity(call) {
+        function binding(raw) {
+            const e = comparisonExpression(raw);
+            if (ts.isIdentifier(e)) {
+                const d = checker.getSymbolAtLocation(e)?.declarations?.[0];
+                if (!d)
+                    return;
+                let imported;
+                let kind;
+                let name;
+                if (ts.isImportClause(d) && !d.isTypeOnly) {
+                    imported = d.parent;
+                    kind = "callable";
+                }
+                else if (ts.isNamespaceImport(d) && !d.parent.isTypeOnly) {
+                    imported = d.parent.parent;
+                    kind = "namespace";
+                }
+                else if (ts.isImportSpecifier(d) &&
+                    !d.isTypeOnly &&
+                    !d.parent.parent.isTypeOnly) {
+                    imported = d.parent.parent.parent;
+                    name = (d.propertyName ?? d.name).text;
+                    kind =
+                        name === "default" || name === "strict" ? "callable" : "method";
+                }
+                else
+                    return;
+                if (!ts.isImportDeclaration(imported) ||
+                    !ts.isStringLiteralLike(imported.moduleSpecifier))
+                    return;
+                const specifier = imported.moduleSpecifier.text;
+                if (![
+                    "node:assert",
+                    "node:assert/strict",
+                    "assert",
+                    "assert/strict",
+                ].includes(specifier))
+                    return;
+                let module = specifier.startsWith("node:")
+                    ? specifier
+                    : `node:${specifier}`;
+                if (name === "strict")
+                    module = "node:assert/strict";
+                if (kind === "method" &&
+                    (!name || name === "assert" || !Object.hasOwn(ASSERT_STRENGTH, name)))
+                    return;
+                return { module, kind, method: kind === "method" ? name : undefined };
+            }
+            if (!ts.isPropertyAccessExpression(e))
+                return;
+            const receiver = binding(e.expression);
+            if (!receiver || receiver.kind === "method")
+                return;
+            if (e.name.text === "strict")
+                return { module: "node:assert/strict", kind: "callable" };
+            if (e.name.text === "default" && receiver.kind === "namespace")
+                return { module: receiver.module, kind: "callable" };
+            if (e.name.text === "assert" ||
+                !Object.hasOwn(ASSERT_STRENGTH, e.name.text))
+                return;
+            return { module: receiver.module, kind: "method", method: e.name.text };
+        }
+        const resolved = binding(call.expression);
+        if (!resolved || resolved.kind === "namespace")
+            return;
+        return { module: resolved.module, method: resolved.method ?? "ok" };
+    }
+    function comparisonLocation(n) {
+        const sf = n.getSourceFile();
+        return `${rel(sf)}:${n.getStart(sf)}:${n.getEnd()}`;
+    }
+    function immutableBinding(expr, seen = new Set()) {
+        const e = comparisonExpression(expr);
+        if (!ts.isIdentifier(e) || seen.size >= 32)
+            return undefined;
+        const d = declOf(e);
+        if (!d ||
+            !ts.isVariableDeclaration(d) ||
+            !ts.isIdentifier(d.name) ||
+            !d.initializer ||
+            !ts.isVariableDeclarationList(d.parent) ||
+            !(d.parent.flags & ts.NodeFlags.Const) ||
+            seen.has(d))
+            return undefined;
+        seen.add(d);
+        // A copy of a mutable binding has its own identity, not a live alias.
+        return immutableBinding(d.initializer, seen) ?? comparisonLocation(d);
+    }
+    // Trace only const aliases and await. Unlike immutableBinding, this describes
+    // an input dependency: awaiting a Promise or thenable need not preserve its
+    // value, nor do two awaits necessarily return the same result.
+    function comparisonInput(expr, seen = new Set()) {
+        const e = comparisonExpression(expr);
+        if (seen.size >= 32 || seen.has(e))
+            return undefined;
+        seen.add(e);
+        if (ts.isAwaitExpression(e)) {
+            const input = comparisonInput(e.expression, seen);
+            return (input && {
+                binding: input.binding,
+                awaits: [comparisonLocation(e), ...input.awaits],
+            });
+        }
+        if (!ts.isIdentifier(e))
+            return undefined;
+        const d = declOf(e);
+        if (!d ||
+            !ts.isVariableDeclaration(d) ||
+            !ts.isIdentifier(d.name) ||
+            !d.initializer ||
+            !ts.isVariableDeclarationList(d.parent) ||
+            !(d.parent.flags & ts.NodeFlags.Const) ||
+            seen.has(d))
+            return undefined;
+        seen.add(d);
+        // A copied mutable binding, call or property read anchors a fresh const
+        // input. Do not equate repeated calls/getters or follow mutable aliases.
+        return (comparisonInput(d.initializer, seen) ?? {
+            binding: comparisonLocation(d),
+            awaits: [],
+        });
+    }
+    /** Literal syntax only: do not resolve globals, call code or lose signed zero. */
+    function sourcePrimitive(raw) {
+        const e = comparisonExpression(raw);
+        if (ts.isStringLiteralLike(e)) {
+            // Rust strings cannot represent lone UTF-16 surrogates. Leave those and
+            // large literals unsupported instead of changing or truncating their value.
+            if (e.text.length > 4096)
+                return;
+            for (const point of e.text)
+                if (point.length === 1 &&
+                    point.charCodeAt(0) >= 0xd800 &&
+                    point.charCodeAt(0) <= 0xdfff)
+                    return;
+            return { kind: "string", value: e.text };
+        }
+        if (e.kind === ts.SyntaxKind.TrueKeyword)
+            return { kind: "boolean", value: true };
+        if (e.kind === ts.SyntaxKind.FalseKeyword)
+            return { kind: "boolean", value: false };
+        if (e.kind === ts.SyntaxKind.NullKeyword)
+            return { kind: "null" };
+        let number;
+        if (ts.isNumericLiteral(e))
+            number = Number(e.text);
+        else if (ts.isPrefixUnaryExpression(e) &&
+            [ts.SyntaxKind.MinusToken, ts.SyntaxKind.PlusToken].includes(e.operator) &&
+            ts.isNumericLiteral(e.operand))
+            number =
+                Number(e.operand.text) *
+                    (e.operator === ts.SyntaxKind.MinusToken ? -1 : 1);
+        else
+            return;
+        if (!Number.isFinite(number))
+            return;
+        return {
+            kind: "number",
+            value: Object.is(number, -0) ? "-0" : String(number),
+        };
+    }
+    function nativeComparison(call) {
+        const callee = comparisonExpression(call.expression);
+        if (!ts.isPropertyAccessExpression(callee) || call.arguments.length < 2)
+            return undefined;
+        const receiver = comparisonExpression(callee.expression);
+        if (!ts.isIdentifier(receiver))
+            return undefined;
+        // Read the import declaration itself, before resolving its module alias.
+        // A helper named `assert` is not the native assertion implementation.
+        const declaration = checker.getSymbolAtLocation(receiver)?.declarations?.[0];
+        if (!declaration ||
+            !(ts.isImportClause(declaration) || ts.isNamespaceImport(declaration)))
+            return undefined;
+        const imported = ts.isImportClause(declaration)
+            ? declaration.parent
+            : declaration.parent.parent;
+        if (!ts.isStringLiteralLike(imported.moduleSpecifier))
+            return undefined;
+        const module = imported.moduleSpecifier.text;
+        if (![
+            "node:assert",
+            "node:assert/strict",
+            "assert",
+            "assert/strict",
+        ].includes(module))
+            return undefined;
+        const strict = module.endsWith("/strict");
+        const predicates = {
+            equal: strict ? "node-same-value" : "node-loose-equality",
+            strictEqual: "node-same-value",
+            notEqual: strict ? "node-not-same-value" : "node-not-loose-equality",
+            notStrictEqual: "node-not-same-value",
+            deepEqual: strict ? "node-deep-strict-equality" : "node-deep-equality",
+            deepStrictEqual: "node-deep-strict-equality",
+        };
+        const predicate = predicates[callee.name.text];
+        if (!predicate)
+            return undefined;
+        const operand = (arg) => ({
+            source: comparisonLocation(arg),
+            binding: immutableBinding(arg),
+            value: sourcePrimitive(arg),
+        });
+        const actual = operand(call.arguments[0]);
+        const expected = operand(call.arguments[1]);
+        const actualInput = comparisonInput(call.arguments[0]);
+        const expectedInput = comparisonInput(call.arguments[1]);
+        const sharedAwaitedInput = actualInput &&
+            expectedInput &&
+            actualInput.binding === expectedInput.binding &&
+            actualInput.awaits.length + expectedInput.awaits.length > 0;
+        const sameBinding = actual.binding && actual.binding === expected.binding;
+        if (!sameBinding && sharedAwaitedInput) {
+            actual.input = actualInput;
+            expected.input = expectedInput;
+        }
+        return {
+            predicate,
+            actual,
+            expected,
+            relation: sameBinding
+                ? "same-immutable-binding"
+                : sharedAwaitedInput
+                    ? "shared-input-through-await"
+                    : "unresolved",
+        };
+    }
+    function nativeContextMock(call) {
+        const callee = unwrap(call.expression);
+        if (!ts.isPropertyAccessExpression(callee))
+            return false;
+        const tracker = unwrap(callee.expression);
+        if (!ts.isPropertyAccessExpression(tracker) || tracker.name.text !== "mock")
+            return false;
+        const context = declOf(unwrap(tracker.expression));
+        if (!context || !ts.isParameter(context))
+            return false;
+        const callback = context.parent;
+        if (!(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) ||
+            callback.parameters[0] !== context ||
+            !ts.isCallExpression(callback.parent))
+            return false;
+        return nativeTestRegistration(callback.parent);
+    }
+    function nativeTestRegistration(call) {
+        const registration = comparisonExpression(call.expression);
+        if (!ts.isIdentifier(registration))
+            return false;
+        const declaration = checker.getSymbolAtLocation(registration)?.declarations?.[0];
+        if (!declaration ||
+            !(ts.isImportSpecifier(declaration) || ts.isImportClause(declaration)))
+            return false;
+        if (ts.isImportSpecifier(declaration) &&
+            !["test", "it"].includes((declaration.propertyName ?? declaration.name).text))
+            return false;
+        const imported = ts.isImportSpecifier(declaration)
+            ? declaration.parent.parent.parent
+            : declaration.parent;
+        return (ts.isStringLiteralLike(imported.moduleSpecifier) &&
+            imported.moduleSpecifier.text === "node:test");
+    }
+    function mockProjection(o) {
+        if (!o.kind.startsWith("mock:console."))
+            return undefined;
+        const path = o.path;
+        const joined = path.join(".");
+        const kind = joined === "mock.callCount()" ||
+            (path[0] === "mock" &&
+                path[1] === "calls" &&
+                path[path.length - 1] === "length" &&
+                path.slice(2, -1).every((step) => /^slice\([\s\S]*\)$/.test(step)))
+            ? "call-count"
+            : joined === "mock.calls"
+                ? "call-history"
+                : /(?:^|\.)arguments(?:\.\[\d+\])?$/.test(joined)
+                    ? "call-arguments"
+                    : "projection";
+        return { target: o.kind.slice(5), kind, path };
+    }
+    /** Follow source projections to a Promise, then check only its resolver mapping.
+     * This does not prove that the resolved object was not subsequently mutated,
+     * or that the selected child is the producer of every covered exit site. */
+    function childExitSource(expr) {
+        const info = {
+            model: "node-child-exit-source-v1",
+            status: "unresolved",
+            reason: "unsupported-promise-source",
+            operand: comparisonLocation(expr),
+            helperCalls: [],
+        };
+        const seen = new Set();
+        const carriers = new Map();
+        const helperReturns = new Map();
+        let openCarrier = false;
+        const fail = (reason) => ({ ...info, reason });
+        const nativeSpawn = (call) => {
+            const callee = comparisonExpression(call.expression);
+            if (!ts.isIdentifier(callee))
+                return false;
+            const raw = checker.getSymbolAtLocation(callee)?.declarations?.[0];
+            if (!raw || !ts.isImportSpecifier(raw))
+                return false;
+            const imported = raw.parent.parent.parent;
+            return ((raw.propertyName ?? raw.name).text === "spawn" &&
+                ts.isStringLiteralLike(imported.moduleSpecifier) &&
+                (imported.moduleSpecifier.text === "node:child_process" ||
+                    imported.moduleSpecifier.text === "child_process"));
+        };
+        const property = (object, key) => {
+            // No spreads, getters, computed keys, duplicates or inherited properties.
+            const entries = new Map();
+            for (const p of object.properties) {
+                if (!(ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) ||
+                    !(ts.isIdentifier(p.name) || ts.isStringLiteralLike(p.name)))
+                    return;
+                const name = p.name.text;
+                if (name === "__proto__" || name === "then" || entries.has(name))
+                    return;
+                entries.set(name, ts.isPropertyAssignment(p) ? p.initializer : p.name);
+            }
+            return entries.get(key);
+        };
+        const trace = (raw, path, awaitedPath, scope = enclosingFunction(expr)) => {
+            const e = comparisonExpression(raw);
+            if (seen.size >= 48 || seen.has(e))
+                return;
+            seen.add(e);
+            if (ts.isAwaitExpression(e))
+                return trace(e.expression, path, [...path], scope);
+            if (ts.isPropertyAccessExpression(e))
+                return trace(e.expression, [e.name.text, ...path], awaitedPath, scope);
+            if (ts.isIdentifier(e)) {
+                const d = declOf(e);
+                if (d &&
+                    ts.isVariableDeclaration(d) &&
+                    ts.isIdentifier(d.name) &&
+                    d.initializer &&
+                    ts.isVariableDeclarationList(d.parent) &&
+                    d.parent.flags & ts.NodeFlags.Const) {
+                    if (!scope || enclosingFunction(d) !== scope)
+                        openCarrier = true;
+                    const uses = carriers.get(d) ?? new Set();
+                    uses.add(e);
+                    carriers.set(d, uses);
+                    return trace(d.initializer, path, awaitedPath, scope);
+                }
+                return;
+            }
+            if (ts.isObjectLiteralExpression(e)) {
+                const next = path.length ? property(e, path[0]) : undefined;
+                return next
+                    ? trace(next, path.slice(1), awaitedPath, scope)
+                    : undefined;
+            }
+            if (ts.isCallExpression(e) &&
+                ts.isIdentifier(comparisonExpression(e.expression))) {
+                const d = declOf(comparisonExpression(e.expression));
+                const fn = d && ts.isFunctionDeclaration(d) ? d : undefined;
+                if (!fn?.body ||
+                    fn.getSourceFile().isDeclarationFile ||
+                    seen.has(fn) ||
+                    fn.asteriskToken ||
+                    fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
+                    return;
+                seen.add(fn);
+                // Only one direct top-level return. Do not select the first branch or a
+                // nested callback's return, and do not treat a helper name as a contract.
+                const returns = [];
+                let budget = 4096;
+                const scan = (n) => {
+                    if (--budget < 0)
+                        return;
+                    if (ts.isReturnStatement(n))
+                        returns.push(n);
+                    else if (!ts.isFunctionLike(n))
+                        ts.forEachChild(n, scan);
+                };
+                scan(fn.body);
+                const [ret] = returns;
+                if (budget < 0 ||
+                    returns.length !== 1 ||
+                    ret.parent !== fn.body ||
+                    !ret.expression)
+                    return;
+                info.helperCalls.push(comparisonLocation(e));
+                helperReturns.set(e, ret.expression);
+                return trace(ret.expression, path, awaitedPath, fn);
+            }
+            if (!ts.isNewExpression(e) ||
+                !ts.isIdentifier(e.expression) ||
+                e.expression.text !== "Promise")
+                return;
+            // Discovery is structural only. A Promise with no exit/close listener is
+            // not an exit observation, even if a comment contains listener-shaped text.
+            let hasEvent = false, discoveryBudget = 4096;
+            const discover = (n) => {
+                if (--discoveryBudget < 0 || hasEvent)
+                    return;
+                if (ts.isCallExpression(n) &&
+                    ts.isPropertyAccessExpression(n.expression) &&
+                    ["on", "once"].includes(n.expression.name.text) &&
+                    n.arguments[0] &&
+                    ts.isStringLiteralLike(n.arguments[0]) &&
+                    ["exit", "close"].includes(n.arguments[0].text))
+                    hasEvent = true;
+                ts.forEachChild(n, discover);
+            };
+            if (e.arguments?.[0])
+                discover(e.arguments[0]);
+            if (!hasEvent)
+                return;
+            info.promise = comparisonLocation(e);
+            const promiseBinding = declOf(e.expression);
+            // Compiler sessions may omit standard libraries. As with the native mock
+            // model, global built-ins are assumed unmodified; a project declaration
+            // with this name is never accepted as that global.
+            if (promiseBinding && !promiseBinding.getSourceFile().isDeclarationFile)
+                return fail("native-promise-binding-unverified");
+            if (JSON.stringify(awaitedPath) !== JSON.stringify(path))
+                return fail("promise-result-not-awaited-before-projection");
+            const executor = e.arguments?.[0] && comparisonExpression(e.arguments[0]);
+            if (e.arguments?.length !== 1 ||
+                !executor ||
+                !(ts.isArrowFunction(executor) || ts.isFunctionExpression(executor)) ||
+                !ts.isBlock(executor.body) ||
+                executor.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
+                return fail("unsupported-promise-executor");
+            const [resolveParam, rejectParam] = executor.parameters;
+            if (!resolveParam ||
+                executor.parameters.length > 2 ||
+                executor.parameters.some((p) => !ts.isIdentifier(p.name) || p.initializer || p.dotDotDotToken))
+                return fail("unsupported-resolver-binding");
+            let eventCall;
+            for (const statement of executor.body.statements) {
+                if (!ts.isExpressionStatement(statement) ||
+                    !ts.isCallExpression(statement.expression))
+                    return fail("unsupported-executor-statement");
+                const call = statement.expression;
+                if (!ts.isPropertyAccessExpression(call.expression) ||
+                    !["on", "once"].includes(call.expression.name.text) ||
+                    call.arguments.length !== 2 ||
+                    !ts.isStringLiteralLike(call.arguments[0]))
+                    return fail("competing-or-unsupported-settlement");
+                const event = call.arguments[0].text;
+                if (event === "error" &&
+                    rejectParam &&
+                    declOf(comparisonExpression(call.arguments[1])) === rejectParam)
+                    continue;
+                if (!["exit", "close"].includes(event) || eventCall)
+                    return fail("competing-or-unsupported-settlement");
+                eventCall = call;
+            }
+            if (!eventCall)
+                return fail("missing-exit-listener");
+            const member = eventCall.expression;
+            const child = declOf(comparisonExpression(member.expression));
+            if (!child ||
+                !ts.isVariableDeclaration(child) ||
+                !child.initializer ||
+                !ts.isVariableDeclarationList(child.parent) ||
+                !(child.parent.flags & ts.NodeFlags.Const))
+                return fail("child-binding-unverified");
+            const spawn = comparisonExpression(child.initializer);
+            if (!ts.isCallExpression(spawn) || !nativeSpawn(spawn))
+                return fail("native-child-spawn-unverified");
+            info.spawn = comparisonLocation(spawn);
+            info.event = {
+                source: comparisonLocation(eventCall),
+                name: eventCall.arguments[0].text,
+            };
+            const callback = comparisonExpression(eventCall.arguments[1]);
+            if (declOf(callback) === resolveParam) {
+                if (path.length)
+                    return fail("unsupported-exit-result-projection");
+                info.resolution = {
+                    status: "source-checked",
+                    source: comparisonLocation(callback),
+                    eventArgument: "code",
+                };
+                return fail("producer-instance-link-unverified");
+            }
+            if (!(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) ||
+                callback.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ||
+                callback.parameters.length > 2 ||
+                callback.parameters.some((p) => !ts.isIdentifier(p.name) || p.initializer || p.dotDotDotToken))
+                return fail("unsupported-exit-callback");
+            let body;
+            if (!ts.isBlock(callback.body))
+                body = callback.body;
+            else if (callback.body.statements.length === 1) {
+                const statement = callback.body.statements[0];
+                if (ts.isExpressionStatement(statement))
+                    body = statement.expression;
+                else if (ts.isReturnStatement(statement))
+                    body = statement.expression;
+            }
+            const call = body && comparisonExpression(body);
+            if (!call ||
+                !ts.isCallExpression(call) ||
+                declOf(comparisonExpression(call.expression)) !== resolveParam ||
+                call.arguments.length !== 1)
+                return fail("unsupported-exit-resolver");
+            let value = comparisonExpression(call.arguments[0]);
+            let field;
+            if (path.length) {
+                if (path.length !== 1 || !ts.isObjectLiteralExpression(value))
+                    return fail("unsupported-exit-result-projection");
+                field = path[0];
+                for (const member of value.properties) {
+                    if (!(ts.isPropertyAssignment(member) ||
+                        ts.isShorthandPropertyAssignment(member)))
+                        return fail("unsupported-resolved-object");
+                    const item = comparisonExpression(ts.isPropertyAssignment(member) ? member.initializer : member.name);
+                    if (!(ts.isIdentifier(item) &&
+                        callback.parameters.some((p) => declOf(item) === p)) &&
+                        !ts.isStringLiteralLike(item) &&
+                        !ts.isNumericLiteral(item) &&
+                        ![
+                            ts.SyntaxKind.NullKeyword,
+                            ts.SyntaxKind.TrueKeyword,
+                            ts.SyntaxKind.FalseKeyword,
+                        ].includes(item.kind))
+                        return fail("transformed-or-constant-event-value");
+                }
+                const projected = property(value, field);
+                if (!projected)
+                    return fail("unsupported-resolved-object");
+                value = comparisonExpression(projected);
+            }
+            if (!ts.isIdentifier(value))
+                return fail("transformed-or-constant-event-value");
+            const index = callback.parameters.findIndex((p) => ts.isIdentifier(p.name) &&
+                !p.initializer &&
+                !p.dotDotDotToken &&
+                declOf(value) === p);
+            if (index !== 0 && index !== 1)
+                return fail("resolved-value-is-not-event-argument");
+            info.resolution = {
+                status: "source-checked",
+                source: comparisonLocation(call),
+                ...(field ? { field } : {}),
+                eventArgument: index === 0 ? "code" : "signal",
+            };
+            return fail("producer-instance-link-unverified");
+        };
+        const result = trace(expr, []);
+        if (!result?.resolution)
+            return result;
+        // The resolver's fresh object cannot change in transit if its Promise and
+        // every followed carrier stay closed to the selected read. Inspect all uses
+        // of each local binding, including closures, not just preceding statements.
+        // This proves preservation of the event argument, not its producer identity.
+        const consumer = {
+            status: "unresolved",
+            reason: "result-carrier-escapes-or-is-reused",
+            bindings: [...carriers.keys()].map(comparisonLocation),
+            read: comparisonLocation(expr),
+            blockedAt: undefined,
+        };
+        result.consumer = consumer;
+        if (openCarrier) {
+            consumer.reason = "nonlocal-result-carrier";
+            return result;
+        }
+        const outer = (n) => {
+            let p = n.parent;
+            while (p &&
+                ts.isExpression(p) &&
+                comparisonExpression(p) === comparisonExpression(n)) {
+                n = p;
+                p = n.parent;
+            }
+            return n;
+        };
+        const discardedAwait = (n) => {
+            const p = outer(n).parent;
+            return (ts.isAwaitExpression(p) && ts.isExpressionStatement(outer(p).parent));
+        };
+        const discardedRace = (n) => {
+            const array = n.parent;
+            if (!ts.isArrayLiteralExpression(array))
+                return false;
+            const call = array.parent;
+            if (!ts.isCallExpression(call) ||
+                call.arguments.length !== 1 ||
+                !ts.isPropertyAccessExpression(call.expression) ||
+                call.expression.name.text !== "race")
+                return false;
+            const ctor = call.expression.expression;
+            const binding = declOf(ctor);
+            return (ts.isIdentifier(ctor) &&
+                ctor.text === "Promise" &&
+                (!binding || binding.getSourceFile().isDeclarationFile) &&
+                discardedAwait(call));
+        };
+        const siblingArrowRead = (n, d) => {
+            // A fresh helper return may also expose independent arrow readers, e.g.
+            // buffered stdout. Arrows cannot receive the carrier as their `this`.
+            // Any captured use of the result Promise is audited separately below.
+            const access = n.parent;
+            if (!ts.isPropertyAccessExpression(access) || access.expression !== n)
+                return false;
+            const call = access.parent;
+            if (!ts.isCallExpression(call) ||
+                call.expression !== access ||
+                call.arguments.length)
+                return false;
+            const init = d.initializer && comparisonExpression(d.initializer);
+            const value = init && ts.isCallExpression(init) ? helperReturns.get(init) : init;
+            const object = value && comparisonExpression(value);
+            if (!object || !ts.isObjectLiteralExpression(object))
+                return false;
+            const member = property(object, access.name.text);
+            return !!member && ts.isArrowFunction(comparisonExpression(member));
+        };
+        let budget = 16384;
+        for (const [d, uses] of carriers) {
+            const scope = enclosingFunction(d);
+            if (!scope)
+                return result;
+            let closed = true;
+            const scan = (n) => {
+                if (--budget < 0 || !closed)
+                    return;
+                const callee = ts.isCallExpression(n)
+                    ? comparisonExpression(n.expression)
+                    : undefined;
+                if (ts.isWithStatement(n) ||
+                    (callee && ts.isIdentifier(callee) && callee.text === "eval")) {
+                    closed = false;
+                    consumer.reason = "reflective-carrier-access";
+                    consumer.blockedAt = comparisonLocation(n);
+                    return;
+                }
+                if (ts.isIdentifier(n) &&
+                    n !== d.name &&
+                    declOf(n) === d &&
+                    !uses.has(n) &&
+                    !discardedAwait(n) &&
+                    !discardedRace(n) &&
+                    !siblingArrowRead(n, d)) {
+                    closed = false;
+                    consumer.blockedAt = comparisonLocation(n);
+                    return;
+                }
+                ts.forEachChild(n, scan);
+            };
+            scan(scope);
+            if (!closed || budget < 0) {
+                if (budget < 0)
+                    consumer.reason = "consumer-scan-budget";
+                return result;
+            }
+        }
+        consumer.status = "source-checked";
+        delete consumer.reason;
+        return result;
+    }
     function originOf(expr, depth = 0) {
         // each property-access segment costs one level: `admin.rest.resources.Article.find.mock.calls.map(...)` read
         // through a local helper is 10 deep; runaway recursion through helpers is bounded by paramBindings instead
@@ -1740,11 +2418,21 @@ export function analyzeWithFrontend(options, frontend) {
                 callee.name.text === "method" &&
                 callee.expression.getText().endsWith(".mock") &&
                 e.arguments.length >= 2 &&
-                ts.isStringLiteralLike(e.arguments[1]))
+                ts.isStringLiteralLike(e.arguments[1])) {
+                // Keep a same-named user helper out of the native mock model. Unsupported
+                // tracker/receiver aliases remain unknown rather than acquiring stream credit.
+                const receiver = unwrap(e.arguments[0]);
+                const declaration = declOf(receiver);
+                if (!nativeContextMock(e) ||
+                    !ts.isIdentifier(receiver) ||
+                    receiver.text !== "console" ||
+                    (declaration && !declaration.getSourceFile().isDeclarationFile))
+                    return undefined;
                 return {
                     kind: `mock:${e.arguments[0].getText()}.${e.arguments[1].text}`,
                     path: [],
                 };
+            }
             if (ts.isIdentifier(callee)) {
                 // Resolve the declaration below. A familiar helper name is not a
                 // contract, nor does it identify the particular process/socket observed.
@@ -1780,10 +2468,14 @@ export function analyzeWithFrontend(options, frontend) {
                     if (hook)
                         return hook;
                 }
-                if (["String", "Number", "Boolean"].includes(callee.text))
-                    return e.arguments[0]
+                if (["String", "Number", "Boolean"].includes(callee.text)) {
+                    const base = e.arguments[0]
                         ? originOf(e.arguments[0], depth + 1)
                         : undefined;
+                    return base?.kind.startsWith("mock:")
+                        ? { ...base, path: [...base.path, `${callee.text}()`] }
+                        : base;
+                }
                 const d = declOf(callee);
                 if (d && isProdFile(d.getSourceFile()))
                     return { kind: "prod:" + declaredName(d, callee.text), path: [] };
@@ -1831,10 +2523,14 @@ export function analyzeWithFrontend(options, frontend) {
             if (ts.isPropertyAccessExpression(callee)) {
                 const name = callee.name.text;
                 const objText = callee.expression.getText();
-                if (["JSON", "Object", "Array", "Promise"].includes(objText))
-                    return e.arguments[0]
+                if (["JSON", "Object", "Array", "Promise"].includes(objText)) {
+                    const base = e.arguments[0]
                         ? originOf(e.arguments[0], depth + 1)
                         : undefined;
+                    return base?.kind.startsWith("mock:")
+                        ? { ...base, path: [...base.path, `${objText}.${name}()`] }
+                        : base;
+                }
                 // vi.mocked(x) is x; vi.importActual('~/x') is the real module
                 if ((objText === "vi" || objText === "jest") &&
                     name === "mocked" &&
@@ -1848,7 +2544,10 @@ export function analyzeWithFrontend(options, frontend) {
                 const base = originOf(callee.expression, depth + 1);
                 if (!base)
                     return undefined;
-                const o = { ...base, path: [...base.path, name + "()"] };
+                const step = base.kind.startsWith("mock:")
+                    ? `${name}(${e.arguments.map((arg) => arg.getText()).join(", ")})`
+                    : name + "()";
+                const o = { ...base, path: [...base.path, step] };
                 // promise.catch(e => e) carries the rejection; promise.then(onOk, onErr) carries either
                 if (name === "catch" && e.arguments[0])
                     o.thrown = "only";
@@ -1902,7 +2601,10 @@ export function analyzeWithFrontend(options, frontend) {
         }
         if (ts.isElementAccessExpression(e)) {
             const b = originOf(e.expression, depth + 1);
-            return b ? { ...b, path: [...b.path, "[]"] } : undefined;
+            const step = b?.kind.startsWith("mock:")
+                ? `[${e.argumentExpression.getText()}]`
+                : "[]";
+            return b ? { ...b, path: [...b.path, step] } : undefined;
         }
         if (ts.isConditionalExpression(e))
             return undefined; // selected branch needs value-flow evidence
@@ -1915,8 +2617,12 @@ export function analyzeWithFrontend(options, frontend) {
             // from the first operand whose name can be resolved.
             return undefined;
         }
-        if (ts.isPrefixUnaryExpression(e))
-            return originOf(e.operand, depth + 1);
+        if (ts.isPrefixUnaryExpression(e)) {
+            const base = originOf(e.operand, depth + 1);
+            return base?.kind.startsWith("mock:")
+                ? { ...base, path: [...base.path, `unary:${e.operator}`] }
+                : base;
+        }
         if (ts.isIdentifier(e)) {
             // imports first, by their import declaration: alias resolution can fail on deep re-exports
             const raw = checker.getSymbolAtLocation(e)?.declarations?.[0];
@@ -2014,11 +2720,6 @@ export function analyzeWithFrontend(options, frontend) {
                     if (fed)
                         return { kind: fed, path: [] };
                 }
-                // promise resolved from a child process 'close'/'exit' event carries the exit code
-                if (ts.isNewExpression(init) &&
-                    init.expression.getText() === "Promise" &&
-                    /\.(once|on)\(\s*['"](close|exit)['"]/.test(init.getText()))
-                    return { kind: "proc-exit", path: [] };
                 // Mutable scalar aliases need reaching definitions, not the initializer
                 // or first assignment anywhere in the file. Container/stream cases above
                 // retain their separate models.
@@ -2150,8 +2851,6 @@ export function analyzeWithFrontend(options, frontend) {
                 return [{ boundary: "stdout" }];
             case "proc-stderr":
                 return [{ boundary: "stderr" }];
-            case "proc-exit":
-                return [{ boundary: "exit" }];
             case "sdk-client":
                 if (has("sessionId"))
                     return [{ boundary: "client-header", facet: "mcp-session-id" }];
@@ -2204,7 +2903,10 @@ export function analyzeWithFrontend(options, frontend) {
                 // t.mock.method(console, 'log'): a test-owned replacement of a stream sink
                 if (o.kind.startsWith("mock:console."))
                     return [
-                        { boundary: o.kind.endsWith(".error") ? "stderr" : "stdout" },
+                        {
+                            boundary: /\.(error|warn)$/.test(o.kind) ? "stderr" : "stdout",
+                            facet: o.kind.slice(5),
+                        },
                     ];
                 return [];
         }
@@ -2493,7 +3195,74 @@ export function analyzeWithFrontend(options, frontend) {
         const key = `${shape}  [${why}]`;
         unrecognized.set(key, (unrecognized.get(key) ?? 0) + 1);
     }
+    const nativeImportedMethod = (call, module, methods) => {
+        const callee = comparisonExpression(call.expression);
+        if (!ts.isPropertyAccessExpression(callee) ||
+            !methods.includes(callee.name.text))
+            return false;
+        const receiver = comparisonExpression(callee.expression);
+        const d = checker.getSymbolAtLocation(receiver)?.declarations?.[0];
+        const imported = d &&
+            (ts.isImportClause(d)
+                ? d.parent
+                : ts.isNamespaceImport(d)
+                    ? d.parent.parent
+                    : undefined);
+        return (!!imported &&
+            ts.isStringLiteralLike(imported.moduleSpecifier) &&
+            imported.moduleSpecifier.text === module);
+    };
+    const nativeGlobalValue = (expr, name) => {
+        const e = comparisonExpression(expr), d = declOf(e);
+        return (ts.isIdentifier(e) &&
+            e.text === name &&
+            (!d || d.getSourceFile().isDeclarationFile));
+    };
+    const mockModel = {
+        declaration: declOf,
+        location: comparisonLocation,
+        nativeMock: nativeContextMock,
+        nativePredicate: (call) => nativeComparison(call)?.predicate ??
+            (nativeImportedMethod(call, "node:assert/strict", ["match"])
+                ? "node-literal-regexp"
+                : undefined),
+        nativeException: (call) => {
+            const method = nativeAssertionIdentity(call)?.method;
+            return method === "throws" || method === "doesNotThrow"
+                ? method
+                : undefined;
+        },
+        globalError: (expr) => nativeGlobalValue(expr, "Error"),
+        nativeTest: nativeTestRegistration,
+        nativeInspect: (call) => nativeImportedMethod(call, "node:util", ["inspect"]),
+        nativeTty: (expr) => ts.isPropertyAccessExpression(expr) &&
+            expr.name.text === "isTTY" &&
+            ts.isPropertyAccessExpression(expr.expression) &&
+            expr.expression.name.text === "stderr" &&
+            nativeGlobalValue(expr.expression.expression, "process"),
+        nativeAssertion: (call) => nativeImportedMethod(call, "node:assert/strict", [
+            "equal",
+            "strictEqual",
+            "deepEqual",
+            "deepStrictEqual",
+            "match",
+        ]),
+        globalString: (expr) => nativeGlobalValue(expr, "String"),
+        globalConsole: (expr) => {
+            const e = comparisonExpression(expr);
+            const d = declOf(e);
+            return (ts.isIdentifier(e) &&
+                e.text === "console" &&
+                (!d || d.getSourceFile().isDeclarationFile));
+        },
+        production: (node) => isProdFile(node.getSourceFile()),
+        site: (call) => smallestSiteContaining(rel(call.getSourceFile()), call.getStart(), call.getEnd())?.id,
+    };
+    function countModel(fn, row) {
+        return analyzeMockCounts(ts, fn, mockModel, row);
+    }
     function analyzeTestBody(fn, file, line, name, inert = false) {
+        const mockCounts = countModel(fn);
         const observations = [];
         const sinks = [];
         const rendered = new Set();
@@ -2585,15 +3354,26 @@ export function analyzeWithFrontend(options, frontend) {
                 let expected;
                 let negative = false;
                 let rejectsChain = false;
-                if (ts.isPropertyAccessExpression(callee) &&
+                const nativeAssertion = nativeAssertionIdentity(node);
+                if (nativeAssertion)
+                    method = nativeAssertion.method;
+                else if (ts.isPropertyAccessExpression(callee) &&
                     callee.expression.getText() === "assert")
                     method = callee.name.text;
                 else if (ts.isIdentifier(callee) && callee.text === "assert")
                     method = "assert";
                 if (method && ASSERT_STRENGTH[method]) {
                     strength = ASSERT_STRENGTH[method];
-                    actuals = node.arguments.slice(0, 2);
-                    expected = node.arguments[1];
+                    // On a passing native ok/doesNotThrow/doesNotReject call, only the
+                    // first argument participates in the success predicate. The no-error
+                    // methods return before inspecting their optional matcher/message.
+                    // Argument evaluation can still have effects or throw. Do not apply
+                    // this rule to throws/rejects: their matcher and string-ambiguity
+                    // checks can inspect the second value even when an error occurred.
+                    const firstOperandOnly = nativeAssertion !== undefined &&
+                        ["ok", "doesNotThrow", "doesNotReject"].includes(nativeAssertion.method);
+                    actuals = node.arguments.slice(0, firstOperandOnly ? 1 : 2);
+                    expected = firstOperandOnly ? undefined : node.arguments[1];
                     negative = method === "doesNotMatch";
                 }
                 else if (ts.isPropertyAccessExpression(callee)) {
@@ -2628,6 +3408,7 @@ export function analyzeWithFrontend(options, frontend) {
                     /\bexpect\.(objectContaining|arrayContaining|anything|any|stringContaining|stringMatching|closeTo)\s*\(/.test(expected.getText()))
                     strength = "value";
                 if (method && strength) {
+                    const comparison = nativeComparison(node);
                     pragmaCollector.register(node, method, staticTestKey(file, line, name), inert);
                     const s = strength;
                     const pattern = expected &&
@@ -2663,8 +3444,9 @@ export function analyzeWithFrontend(options, frontend) {
                     const observesThrow = rejectsChain ||
                         ["rejects", "throws", "toThrow", "toThrowError"].includes(method);
                     for (const arg of actuals) {
-                        const o = originOf(arg);
                         const unresolvedOperand = (shape) => pending.push({
+                            assertionSource: `${relative(root, sf.fileName)}:${sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1}:${sf.getLineAndCharacterOfPosition(node.getStart(sf)).character + 1}`,
+                            assertionMethod: method,
                             statements: definingStatements(arg),
                             strength: RANK[s] > RANK.value ? "value" : s,
                             negative: !!negative,
@@ -2672,6 +3454,33 @@ export function analyzeWithFrontend(options, frontend) {
                             where: where(node, method),
                             shape: `${arg.getText().replace(/\s+/g, " ").slice(0, 40)} [${shape}]`,
                         });
+                        if (nativeAssertion &&
+                            arg === node.arguments[0] &&
+                            ["throws", "rejects", "doesNotThrow", "doesNotReject"].includes(nativeAssertion.method)) {
+                            // The operand supplies a callback or promise, not the value a
+                            // normal value assertion reads. `doesNotThrow(fn)` ignores fn's
+                            // result; `throws(factory())` catches the returned callback's
+                            // exception, not an exception thrown while evaluating factory().
+                            // Async variants additionally distinguish synchronous invocation,
+                            // promise validation and settlement. The ordinary origin/owner
+                            // model cannot establish those invocation and completion paths.
+                            // Retain the passing assertion as a limit, including when its
+                            // callable's source is recognizable; never invent return credit
+                            // or convert the operand producer's return into a caught throw.
+                            const completion = nativeAssertion.method === "throws"
+                                ? "synchronous throw"
+                                : nativeAssertion.method === "doesNotThrow"
+                                    ? "synchronous normal"
+                                    : nativeAssertion.method === "rejects"
+                                        ? "asynchronous rejection"
+                                        : "asynchronous fulfillment";
+                            unresolvedOperand(`${completion} completion; callback/promise producer and invocation path unresolved`);
+                            continue;
+                        }
+                        const exitSource = childExitSource(arg);
+                        const o = exitSource
+                            ? { kind: "process-exit-source", path: [] }
+                            : originOf(arg);
                         if (!o) {
                             noteUnrecognized(arg, "no origin");
                             unresolvedOperand("no origin");
@@ -2683,13 +3492,24 @@ export function analyzeWithFrontend(options, frontend) {
                         const facetPattern = o.facet?.startsWith("pattern:")
                             ? o.facet.slice(8)
                             : undefined;
-                        const bs = boundariesOf(o);
+                        const bs = exitSource ? [{ boundary: "exit" }] : boundariesOf(o);
+                        const mock = mockProjection(o);
+                        if (mock?.kind === "call-count")
+                            mock.countEvidence = mockCounts.checks.get(node) ?? {
+                                model: "node-sync-console-count-v2",
+                                status: "unresolved",
+                                reason: mockCounts.limitation ?? "unsupported-count-projection",
+                            };
+                        if (mock)
+                            unresolvedOperand(`mock ${mock.kind}; production call identity and projection dependence unresolved`);
                         if (!bs.length && o.kind !== "literal") {
                             noteUnrecognized(arg, o.kind);
                             unresolvedOperand(o.kind);
                         }
-                        // rejects/throws: the function's throw sites are observed as well as (or instead of) its return
-                        if (observesThrow)
+                        // Native first-operand completion was handled above. Its second
+                        // operand supplies an expectation/diagnostic, not a caught operation.
+                        // Non-native inference remains separate from the native model.
+                        if (observesThrow && !nativeAssertion)
                             for (const b of [...bs])
                                 if (b.boundary.startsWith("return:"))
                                     bs.push({ boundary: "throw:" + b.boundary.slice(7) });
@@ -2708,8 +3528,21 @@ export function analyzeWithFrontend(options, frontend) {
                                 where: where(node, method),
                                 assertionSource: `${relative(root, sf.fileName)}:${sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1}:${sf.getLineAndCharacterOfPosition(node.getStart(sf)).character + 1}`,
                                 assertionMethod: method,
+                                ...(mock ? { mock } : {}),
+                                ...(comparison ? { comparison } : {}),
+                                ...(b.boundary === "exit"
+                                    ? {
+                                        processExit: exitSource ?? {
+                                            model: "node-child-exit-source-v1",
+                                            status: "unresolved",
+                                            reason: "unverified-event-channel",
+                                            operand: comparisonLocation(arg),
+                                            helperCalls: [],
+                                        },
+                                    }
+                                    : {}),
                             };
-                            if (callList && b.boundary.startsWith("sink:"))
+                            if (!mock && callList && b.boundary.startsWith("sink:"))
                                 ob.callList = true;
                             if (pattern)
                                 ob.pattern = pattern;
@@ -2729,6 +3562,19 @@ export function analyzeWithFrontend(options, frontend) {
                 }
                 // implicit oracles: awaited reads that throw or time out
                 if (ts.isAwaitExpression(node.parent)) {
+                    if (!(method && strength) && pragmaCollector.hasHint(node)) {
+                        const source = awaitedObservationSource({
+                            syntax: ts,
+                            declaration: declOf,
+                            rawDeclaration: (n) => {
+                                const symbol = checker.getSymbolAtLocation(n);
+                                return symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+                            },
+                            relativeFile: rel,
+                        }, fn, node);
+                        if (source && ts.isPropertyAccessExpression(node.expression))
+                            pragmaCollector.register(node, node.expression.name.text, staticTestKey(file, line, name), inert, source);
+                    }
                     const o = originOf(node);
                     if (o) {
                         const bs = boundariesOf(o);
@@ -2928,6 +3774,7 @@ export function analyzeWithFrontend(options, frontend) {
                     ? arg0.text
                     : arg0.getText(sf).replace(/^[`'"]|[`'"]$/g, "");
                 staticTests.push(st);
+                mockBodies.set(st, decl.body);
             }
             ts.forEachChild(node, visit);
         };
@@ -2998,6 +3845,72 @@ export function analyzeWithFrontend(options, frontend) {
         }
     }
     const staticFor = (rt) => staticById.get(rt.id) ?? staticLink.get(`${rt.file}:${rt.line}`);
+    // A custom registrar's callback can be identified by actual assertion call
+    // points without proving the registrar or its captured row. Keep that weaker
+    // relationship explicit. In particular, a wrapper may change the title, call
+    // this same body with other inputs, catch failures, or run other callbacks.
+    // Do this AFTER legacy linking: recovered bodies must never be candidates for
+    // another attempt's title/rank/nearest-line fallback.
+    const witnessedBodies = new Map();
+    for (const sf of allFiles) {
+        if (!isTestFile(sf))
+            continue;
+        const visit = (node) => {
+            if (ts.isCallExpression(node) &&
+                node.arguments.length >= 2 &&
+                !enclosingFunction(node) &&
+                !testDeclaration(node)) {
+                const body = node.arguments[node.arguments.length - 1];
+                if (ts.isArrowFunction(body) || ts.isFunctionExpression(body)) {
+                    const operations = new Map();
+                    const assertion = (n) => {
+                        if (n !== body && ts.isFunctionLike(n))
+                            return;
+                        if (ts.isCallExpression(n)) {
+                            const nativeAssertion = nativeAssertionIdentity(n);
+                            if (nativeAssertion) {
+                                const p = sf.getLineAndCharacterOfPosition(n.getStart(sf));
+                                operations.set(`${rel(sf)}:${p.line + 1}:${p.character + 1}`, `${nativeAssertion.module}.${nativeAssertion.method}`);
+                            }
+                        }
+                        ts.forEachChild(n, assertion);
+                    };
+                    assertion(body);
+                    if (operations.size)
+                        witnessedBodies.set(body, { call: node, operations });
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sf);
+    }
+    const witnessedBodyLinks = new Map();
+    for (const rt of runtimeTests) {
+        if (staticFor(rt) || rt.runner !== "node:test")
+            continue;
+        const phases = runtimePhases.get(rt.id);
+        if (!phases?.length || phases.some((p) => p.status !== "passed"))
+            continue;
+        const matches = [...witnessedBodies].filter(([body, candidate]) => rel(body.getSourceFile()) === rt.file &&
+            phases.every((p) => candidate.operations.get(p.source) === p.op));
+        if (matches.length !== 1)
+            continue;
+        const [body, candidate] = matches[0];
+        const sf = body.getSourceFile();
+        if (!candidate.st) {
+            const call = candidate.call;
+            candidate.st = analyzeTestBody(body, rel(sf), sf.getLineAndCharacterOfPosition(call.getStart(sf)).line + 1, call.arguments[0].getText(sf).slice(0, 60));
+            candidate.st.endLine =
+                sf.getLineAndCharacterOfPosition(call.getEnd()).line + 1;
+            staticTests.push(candidate.st);
+            mockBodies.set(candidate.st, body);
+        }
+        staticById.set(rt.id, candidate.st);
+        witnessedBodyLinks.set(rt.id, {
+            body: comparisonLocation(body),
+            assertions: [...new Set(phases.map((p) => p.source))],
+        });
+    }
     const decisionFacts = new Map();
     function classByName(name, file) {
         const sf = srcByFile.get(file);
@@ -3166,20 +4079,33 @@ export function analyzeWithFrontend(options, frontend) {
         return out;
     }
     /**
-     * Was this site plausibly asserted through an operand whose shape the analysis could not trace? Statement
-     * attribution answers it: the operand's defining statements record which production functions were entered
-     * while they ran, so an operand that entered this site's owner may well read it. Returns the shapes to
-     * report, so "unresolved" can say "limit" instead of sending an agent to write a test that already exists.
+     * Unknown operand dependence is a limit, not proof of an absent assertion.
+     * Synchronous statement attribution can identify a possible relationship but
+     * cannot exclude one across an await, pipe capture, or another async boundary.
+     * A passing unmodeled assertion therefore leaves dependence unresolved for
+     * sites covered by that test. This only changes the reason for an unresolved
+     * candidate: it never supplies an observation, strength, or positive test link.
      */
     function unmodelledOperands(s, covering) {
         buildFunctionIndex();
         const shapes = new Set();
         for (const rt of covering) {
             const byStatement = runtimeStatements.get(rt.id);
-            const st = byStatement ? staticFor(rt) : undefined;
-            if (!byStatement || !st)
+            const st = staticFor(rt);
+            if (!st)
                 continue;
-            for (const p of st.pending)
+            const phases = runtimePhases.get(rt.id);
+            for (const p of st.pending) {
+                if (phases) {
+                    if (!assertionWitnessIssue(phases, p.assertionSource, p.assertionMethod))
+                        shapes.add(`${p.where}: ${p.shape} (passing assertion in covering test ${rt.id}; operand dependence unresolved)`);
+                    // A known failed, mixed, incomplete or unexecuted call cannot supply
+                    // this passing-operand limit. Missing witness transport is separately
+                    // reported by witnessIssues. Legacy statement evidence remains below.
+                    continue;
+                }
+                if (!byStatement)
+                    continue;
                 for (const pos of p.statements) {
                     const attribution = byStatement[pos];
                     if (!attribution)
@@ -3189,6 +4115,7 @@ export function analyzeWithFrontend(options, frontend) {
                     if (entered)
                         shapes.add(p.shape);
                 }
+            }
         }
         return [...shapes];
     }
@@ -3823,6 +4750,9 @@ export function analyzeWithFrontend(options, frontend) {
         assertionMethod: ob.assertionMethod,
         negative: ob.negative,
         callList: ob.callList,
+        mock: ob.mock,
+        comparison: ob.comparison,
+        processExit: ob.processExit,
         weak: ob.weak,
         implicit: ob.implicit,
         runtime: ob.runtime,
@@ -3834,12 +4764,93 @@ export function analyzeWithFrontend(options, frontend) {
                 .length > 1
             : undefined,
     });
-    const factTests = runtimeTests
-        .map((rt) => {
+    const rowPlans = new Map();
+    const runtimeRowTitles = new Map();
+    for (const rt of runtimeTests) {
+        const key = JSON.stringify([rt.file, rt.title]);
+        runtimeRowTitles.set(key, (runtimeRowTitles.get(key) ?? 0) + 1);
+    }
+    function runtimeCountObservations(st, rt) {
+        const body = mockBodies.get(st);
+        if (!body || !st.observations.some((ob) => ob.mock?.kind === "call-count"))
+            return st.observations;
+        if (!rowPlans.has(body))
+            rowPlans.set(body, sourceTestRows(ts, body, {
+                declaration: declOf,
+                location: comparisonLocation,
+                nativeTest: nativeTestRegistration,
+            }));
+        const plan = rowPlans.get(body);
+        if (!plan)
+            return st.observations;
+        const row = rt.title === undefined
+            ? undefined
+            : plan.rows.find((r) => r.evidence.title === rt.title);
+        const duplicate = (runtimeRowTitles.get(JSON.stringify([rt.file, rt.title])) ?? 0) > 1;
+        const reason = plan.reason ??
+            (rt.runner !== "node:test"
+                ? "unsupported-row-runtime-runner"
+                : !row
+                    ? "runtime-title-does-not-identify-source-row"
+                    : duplicate
+                        ? "ambiguous-runtime-row-title"
+                        : undefined);
+        const result = !reason && row ? countModel(body, row) : undefined;
+        const checks = new Map();
+        for (const [node, evidence] of result?.checks ?? []) {
+            const sf = node.getSourceFile(), position = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+            checks.set(`${rel(sf)}:${position.line + 1}:${position.character + 1}`, evidence);
+        }
+        return st.observations.map((ob) => ob.mock?.kind !== "call-count"
+            ? ob
+            : {
+                ...ob,
+                mock: {
+                    ...ob.mock,
+                    countEvidence: checks.get(ob.assertionSource ?? "") ?? {
+                        model: "node-sync-console-count-v2",
+                        status: "unresolved",
+                        reason: reason ??
+                            result?.limitation ??
+                            "unsupported-count-projection",
+                        rowBinding: reason
+                            ? {
+                                model: "node-test-for-of-v1",
+                                status: "unresolved",
+                                reason,
+                            }
+                            : row.evidence,
+                    },
+                },
+            });
+    }
+    const unlinkedTests = runtimeTests
+        .filter((rt) => !staticFor(rt))
+        .map((rt) => ({
+        id: rt.id,
+        file: rt.file,
+        title: rt.title ?? rt.name,
+        reason: "test-source-unlinked",
+    }));
+    const factTests = runtimeTests.map((rt) => {
         const st = staticFor(rt);
+        // A passed runtime attempt stays in the inventory even when source
+        // registration discovery failed. It is NOT an assertion-free test.
         if (!st)
-            return undefined;
-        const checked = st.observations.map((ob) => ({
+            return {
+                id: rt.id,
+                file: rt.file,
+                observations: [],
+                sinks: [],
+                rendered: [],
+                witnessIssues: [
+                    { kind: "test-source-unlinked" },
+                    ...(!runtimePhases.has(rt.id)
+                        ? [{ kind: "capture-unavailable" }]
+                        : []),
+                ],
+            };
+        const checked = runtimeCountObservations(st, rt).map((ob) => ({
             ob,
             kind: witnessIssue(rt.id, ob),
         }));
@@ -3849,6 +4860,9 @@ export function analyzeWithFrontend(options, frontend) {
         // Missing transport applies to the whole test, even when no operand could
         // be modeled. An empty phase file is different from no phase file.
         const witnessIssues = [
+            ...(witnessedBodyLinks.has(rt.id)
+                ? [{ kind: "test-registration-scope-unverified" }]
+                : []),
             ...(!runtimePhases.has(rt.id)
                 ? [{ kind: "capture-unavailable" }]
                 : []),
@@ -3869,8 +4883,7 @@ export function analyzeWithFrontend(options, frontend) {
             sinks: st.sinks,
             rendered: [...st.rendered],
         };
-    })
-        .filter((t) => t !== undefined);
+    });
     // vi.mock boundaries depend on the test file, not the test: one entry per (file, site) pair that has any
     const mocksByTestFile = {};
     for (const file of new Set(factTests.map((t) => t.file))) {
@@ -3883,6 +4896,167 @@ export function analyzeWithFrontend(options, frontend) {
         if (Object.keys(perSite).length)
             mocksByTestFile[file] = perSite;
     }
+    const primitiveModules = new Map();
+    function primitiveDecision(s) {
+        const condition = siteNodes.get(s.id);
+        if (!condition ||
+            !ts.isIdentifier(condition) ||
+            !ts.isIfStatement(condition.parent) ||
+            condition.parent.expression !== condition)
+            return;
+        const branch = condition.parent, fn = enclosingFunction(branch);
+        if (!fn ||
+            !ts.isFunctionDeclaration(fn) ||
+            !fn.name ||
+            !fn.body ||
+            fn.asteriskToken ||
+            fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ||
+            fn.body.statements.length !== 1 ||
+            fn.body.statements[0] !== branch ||
+            fn.parameters.length !== 1)
+            return;
+        const parameter = fn.parameters[0];
+        if (!ts.isIdentifier(parameter.name) ||
+            parameter.initializer ||
+            parameter.dotDotDotToken ||
+            declOf(condition) !== parameter)
+            return;
+        const literalReturn = (statement) => {
+            if (!statement ||
+                !ts.isBlock(statement) ||
+                statement.statements.length !== 1)
+                return;
+            const ret = statement.statements[0];
+            return ts.isReturnStatement(ret) && ret.expression
+                ? sourcePrimitive(ret.expression)
+                : undefined;
+        };
+        const whenTrue = literalReturn(branch.thenStatement), whenFalse = literalReturn(branch.elseStatement);
+        if (!whenTrue || !whenFalse)
+            return;
+        const sf = fn.getSourceFile();
+        if (fn.parent !== sf)
+            return;
+        // A module of declarations only, with no binding writes or dynamic eval.
+        // Do not assume that an exported function declaration can never be replaced.
+        if (!primitiveModules.has(sf)) {
+            let safe = sf.statements.every((n) => ts.isFunctionDeclaration(n) ||
+                ts.isInterfaceDeclaration(n) ||
+                ts.isTypeAliasDeclaration(n) ||
+                ts.isEmptyStatement(n));
+            let budget = 16384;
+            const scan = (n) => {
+                if (!safe)
+                    return;
+                if (--budget < 0 ||
+                    (ts.isIdentifier(n) && n.text === "eval") ||
+                    (ts.isBinaryExpression(n) &&
+                        n.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                        n.operatorToken.kind <= ts.SyntaxKind.LastAssignment) ||
+                    ((ts.isPrefixUnaryExpression(n) || ts.isPostfixUnaryExpression(n)) &&
+                        [
+                            ts.SyntaxKind.PlusPlusToken,
+                            ts.SyntaxKind.MinusMinusToken,
+                        ].includes(n.operator))) {
+                    safe = false;
+                    return;
+                }
+                ts.forEachChild(n, scan);
+            };
+            scan(sf);
+            primitiveModules.set(sf, safe);
+        }
+        if (!primitiveModules.get(sf))
+            return;
+        const covered = runtimeTests.filter((rt) => covers(rt.id, s));
+        const trueTests = testsWithOutcome(s, true), falseTests = testsWithOutcome(s, false);
+        if (!covered.length || !trueTests || !falseTests)
+            return;
+        const checks = [];
+        for (const rt of covered) {
+            const st = staticFor(rt), body = st && mockBodies.get(st);
+            if (!st ||
+                !body ||
+                !ts.isArrowFunction(body) ||
+                !ts.isBlock(body.body) ||
+                body.parameters.length ||
+                body.modifiers?.length ||
+                body.body.statements.length !== 1 ||
+                !ts.isCallExpression(body.parent) ||
+                !nativeTestRegistration(body.parent) ||
+                body.parent.arguments.length !== 2 ||
+                body.parent.arguments[1] !== body ||
+                !ts.isStringLiteralLike(body.parent.arguments[0]) ||
+                !ts.isExpressionStatement(body.parent.parent) ||
+                !ts.isSourceFile(body.parent.parent.parent) ||
+                rt.runner !== "node:test" ||
+                rt.title !== body.parent.arguments[0].text ||
+                (runtimeRowTitles.get(JSON.stringify([rt.file, rt.title])) ?? 0) !== 1)
+                return;
+            // A top-level hook/setup call can replace imports or assertions before the
+            // callback. Such test modules require a separate environment model.
+            if (!body
+                .getSourceFile()
+                .statements.every((statement) => ts.isImportDeclaration(statement) ||
+                ts.isEmptyStatement(statement) ||
+                (ts.isExpressionStatement(statement) &&
+                    ts.isCallExpression(statement.expression) &&
+                    nativeTestRegistration(statement.expression) &&
+                    statement.expression.arguments.length === 2)))
+                return;
+            const statement = body.body.statements[0];
+            if (!ts.isExpressionStatement(statement) ||
+                !ts.isCallExpression(statement.expression))
+                return;
+            const assertion = statement.expression;
+            if (assertion.arguments.length !== 2)
+                return;
+            const comparison = nativeComparison(assertion);
+            if (!comparison ||
+                !["node-same-value", "node-not-same-value"].includes(comparison.predicate))
+                return;
+            const actual = comparisonExpression(assertion.arguments[0]), expected = sourcePrimitive(assertion.arguments[1]);
+            if (!expected ||
+                !ts.isCallExpression(actual) ||
+                actual.questionDotToken ||
+                !ts.isIdentifier(actual.expression) ||
+                declOf(actual.expression) !== fn ||
+                actual.arguments.length !== 1)
+                return;
+            const input = sourcePrimitive(actual.arguments[0]);
+            if (!input ||
+                input.kind !== "boolean" ||
+                trueTests.has(rt.id) !== input.value ||
+                falseTests.has(rt.id) !== !input.value)
+                return;
+            const pos = assertion
+                .getSourceFile()
+                .getLineAndCharacterOfPosition(assertion.getStart());
+            const assertionSource = `${rel(assertion.getSourceFile())}:${pos.line + 1}:${pos.character + 1}`;
+            const test = factTests.find((t) => t.id === rt.id);
+            if (!test ||
+                test.witnessIssues?.length ||
+                test.observations.length !== 1 ||
+                test.observations[0].assertionSource !== assertionSource ||
+                test.observations[0].boundary !== `return:${fn.name.text}` ||
+                test.observations[0].comparison?.predicate !== comparison.predicate)
+                return;
+            checks.push({
+                test: rt.id,
+                assertionSource,
+                predicate: comparison.predicate,
+                expected,
+                originalOutcome: input.value,
+            });
+        }
+        return {
+            model: "js-primitive-decision-v1",
+            source: comparisonLocation(branch),
+            whenTrue,
+            whenFalse,
+            checks,
+        };
+    }
     const factSites = sites.map((s) => {
         const { bounds, reached } = allBoundaries(s);
         const tTrue = testsWithOutcome(s, true);
@@ -3921,6 +5095,7 @@ export function analyzeWithFrontend(options, frontend) {
                 ? {
                     decision: {
                         ...(decisionFacts.get(s.id) ?? {}),
+                        primitive: primitiveDecision(s),
                         outcomes: tTrue && tFalse
                             ? { true: [...tTrue], false: [...tFalse] }
                             : undefined,
@@ -3931,19 +5106,139 @@ export function analyzeWithFrontend(options, frontend) {
             ...(derive.length ? { derive } : {}),
         };
     });
+    const pragmas = pragmaCollector.finish(runtimeTests.flatMap((rt) => {
+        const st = staticFor(rt);
+        return st
+            ? [
+                {
+                    testKey: staticTestKey(st.file, st.line, st.name),
+                    id: rt.id,
+                    phases: runtimePhases.get(rt.id),
+                },
+            ]
+            : [];
+    }));
+    for (const hint of pragmas) {
+        if (!hint.check ||
+            hint.issue ||
+            hint.witness !== "passed" ||
+            hint.candidateSites.length !== 1)
+            continue;
+        const rt = runtimeTests.find((t) => t.id === hint.test);
+        const st = rt && staticFor(rt), body = st && mockBodies.get(st);
+        const target = siteNodes.get(hint.candidateSites[0]);
+        if (hint.check === "count" ||
+            hint.check === "value" ||
+            hint.check === "completion") {
+            const limit = (reason) => {
+                if (hint.check === "completion")
+                    hint.completionSensitivity = {
+                        model: "node-first-test-completion-v1",
+                        status: "unresolved",
+                        reason,
+                    };
+                else if (hint.check === "value")
+                    hint.payloadSensitivity = {
+                        model: "node-closed-payload-sensitivity-v2",
+                        status: "unresolved",
+                        reason,
+                    };
+                else
+                    hint.countSensitivity = {
+                        model: "node-closed-count-sensitivity-v1",
+                        status: "unresolved",
+                        reason,
+                    };
+            };
+            limit("sensitivity-source-or-runtime-unavailable");
+            if (!rt ||
+                rt.runner !== "node:test" ||
+                !body ||
+                !target ||
+                (runtimeRowTitles.get(JSON.stringify([rt.file, rt.title])) ?? 0) !== 1)
+                continue;
+            const location = (n) => {
+                const sf = n.getSourceFile(), p = sf.getLineAndCharacterOfPosition(n.getStart(sf));
+                return `${rel(sf)}:${p.line + 1}:${p.character + 1}`;
+            };
+            let assertion;
+            const find = (n) => {
+                if (ts.isCallExpression(n) && location(n) === hint.assertionSource)
+                    assertion = n;
+                ts.forEachChild(n, find);
+            };
+            find(body);
+            if (!assertion)
+                continue;
+            if (hint.check === "completion") {
+                hint.completionSensitivity = analyzeCompletionSensitivity(ts, body, assertion, target, { ...mockModel, location });
+                continue;
+            }
+            const plan = sourceTestRows(ts, body, mockModel), row = plan?.rows.find((r) => r.evidence.title === rt.title);
+            if (plan && (!row || plan.reason)) {
+                limit(plan.reason ?? "sensitivity-runtime-row-unavailable");
+                continue;
+            }
+            if (hint.check === "value") {
+                hint.payloadSensitivity = analyzePayloadSensitivity(ts, body, assertion, target, { ...mockModel, location }, row);
+                if (hint.payloadSensitivity.status !== "source-checked" && !row) {
+                    hint.directReturnSensitivity = analyzeDirectReturnSensitivity(ts, body, assertion, target, { ...mockModel, location });
+                    if (hint.directReturnSensitivity.status === "source-checked")
+                        delete hint.payloadSensitivity;
+                }
+            }
+            else
+                hint.countSensitivity = analyzeCountSensitivity(ts, body, assertion, target, { ...mockModel, location }, row);
+            continue;
+        }
+        hint.callOmission = {
+            model: "node-first-test-call-omission-v1",
+            status: "unresolved",
+            reason: "omission-source-or-runtime-unavailable",
+        };
+        if (!rt || rt.runner !== "node:test" || !body) {
+            hint.callOmission.reason = !rt
+                ? "omission-runtime-test-unavailable"
+                : rt.runner !== "node:test"
+                    ? "omission-unsupported-runner"
+                    : "omission-static-body-unavailable";
+            continue;
+        }
+        if (!target || !ts.isCallExpression(target)) {
+            hint.callOmission.reason = "omission-target-not-call-expression";
+            continue;
+        }
+        if ((runtimeRowTitles.get(JSON.stringify([rt.file, rt.title])) ?? 0) !== 1) {
+            hint.callOmission.reason = "omission-ambiguous-runtime-title";
+            continue;
+        }
+        let assertion;
+        const originalLocation = (n) => {
+            const sf = n.getSourceFile(), p = sf.getLineAndCharacterOfPosition(n.getStart(sf));
+            return `${rel(sf)}:${p.line + 1}:${p.character + 1}`;
+        };
+        const visit = (n) => {
+            if (ts.isCallExpression(n) &&
+                originalLocation(n) === hint.assertionSource)
+                assertion = n;
+            ts.forEachChild(n, visit);
+        };
+        visit(body);
+        if (!assertion) {
+            hint.callOmission.reason = "omission-assertion-source-unavailable";
+            continue;
+        }
+        const plan = sourceTestRows(ts, body, mockModel);
+        const row = plan?.rows.find((r) => r.evidence.title === rt.title);
+        if (plan && (!row || plan.reason)) {
+            hint.callOmission.reason =
+                plan.reason ?? "omission-runtime-row-unavailable";
+            continue;
+        }
+        hint.callOmission = analyzeFirstTestOmission(ts, body, assertion, target, { ...mockModel, location: originalLocation }, row);
+    }
     return {
-        pragmas: pragmaCollector.finish(runtimeTests.flatMap((rt) => {
-            const st = staticFor(rt);
-            return st
-                ? [
-                    {
-                        testKey: staticTestKey(st.file, st.line, st.name),
-                        id: rt.id,
-                        phases: runtimePhases.get(rt.id),
-                    },
-                ]
-                : [];
-        })),
+        pragmas,
         facts: {
             schema: 1,
             root,
@@ -3955,7 +5250,13 @@ export function analyzeWithFrontend(options, frontend) {
             suppressedObservations,
             observationPolicy: "source-linked-v3: exact successful call witness; rejected witnesses retain typed provenance, not value credit",
             runtimeTests: runtimeTests.length,
-            linkedTests: factTests.length,
+            linkedTests: runtimeTests.length - unlinkedTests.length,
+            unlinkedTests,
+            witnessedBodyLinks: [...witnessedBodyLinks].map(([id, link]) => ({
+                id,
+                ...link,
+                reason: "test-registration-scope-unverified",
+            })),
             staticTests: staticTests.length,
             linkedByAssertionLines: linkedByPhases,
             linkedByTitle,