supercov 0.0.8 → 0.0.11

package/dist/instrumenter.js

@@ -8,11 +8,23 @@ const BEGIN = "__supercovMcdcBegin";
 const CONDITION = "__supercovMcdcCondition";
 const END = "__supercovMcdcEnd";
 const HIT = "__supercovCoverageHit";
+const REGISTER_V2 = "__supercovRegisterProbeV2";
+const END_V2 = "__supercovMcdcEndV2";
+const HIT_V2 = "__supercovCoverageHitV2";
+const FILE_V2 = "__supercovProbeFileV2";
+const CLOCK_V2 = "__supercovProbeClockV2";
+const HITS_V2 = "__supercovProbeHitsV2";
+const DECISIONS_V2 = "__supercovProbeDecisionsV2";
+const COMPLETE_V2 = "__supercovProbeCompleteV2";
 const SELECTION_BEGIN = "__supercovSelectionBegin";
 const SELECTION_RIGHT = "__supercovSelectionRight";
 const SELECTION_END = "__supercovSelectionEnd";
 const WITH_REQUEST_PHASE = "__supercovWithRequestPhase";
 const OPTIONAL_SELECT = "__supercovOptionalSelect";
+const OPTIONAL_CALL_BEGIN = "__supercovOptionalCallBegin";
+const OPTIONAL_CALL_REACHED = "__supercovOptionalCallReached";
+const OPTIONAL_CALL_CONTINUED = "__supercovOptionalCallContinued";
+const OPTIONAL_CALL_END = "__supercovOptionalCallEnd";
 const DEFAULT_SELECTED = "__supercovDefaultSelected";
 const DEFAULT_ENTERED = "__supercovDefaultEntered";
 const TRY_BEGIN = "__supercovTryBegin";
@@ -36,6 +48,26 @@ function sourceFor(code, node) {
     }
     return generate(node).code;
 }
+function restoreClonedOffsets(original, clone) {
+    clone.start = original.start;
+    clone.end = original.end;
+    const keys = t.VISITOR_KEYS[original.type] ?? [];
+    for (const key of keys) {
+        const originalChild = original[key];
+        const clonedChild = clone[key];
+        if (Array.isArray(originalChild) && Array.isArray(clonedChild)) {
+            for (let index = 0; index < originalChild.length; index += 1) {
+                const sourceNode = originalChild[index];
+                const targetNode = clonedChild[index];
+                if (t.isNode(sourceNode) && t.isNode(targetNode))
+                    restoreClonedOffsets(sourceNode, targetNode);
+            }
+        }
+        else if (t.isNode(originalChild) && t.isNode(clonedChild)) {
+            restoreClonedOffsets(originalChild, clonedChild);
+        }
+    }
+}
 function stableId(file, kind, node, suffix = "") {
     return createHash("sha256")
         .update(`${file}:${kind}:${node.start ?? 0}:${node.end ?? 0}:${suffix}`)
@@ -64,6 +96,82 @@ function collectConditions(node, conditions) {
     }
     conditions.push(node);
 }
+function probeV2ReachableVectorCount(node, conditions) {
+    const indices = new WeakMap();
+    for (const [index, condition] of conditions.entries())
+        indices.set(condition, index);
+    const vectors = new Set();
+    const evaluate = (expression, assignment, encoded) => {
+        if (t.isLogicalExpression(expression) &&
+            (expression.operator === "&&" || expression.operator === "||")) {
+            const left = evaluate(expression.left, assignment, encoded);
+            return expression.operator === "&&"
+                ? left && evaluate(expression.right, assignment, encoded)
+                : left || evaluate(expression.right, assignment, encoded);
+        }
+        if (t.isUnaryExpression(expression, { operator: "!" }) &&
+            hasCompoundBooleanDecision(expression.argument))
+            return !evaluate(expression.argument, assignment, encoded);
+        const index = indices.get(expression);
+        if (index === undefined)
+            throw new Error("probe v2 condition index missing");
+        const value = (assignment & (1 << index)) !== 0;
+        encoded.value += (value ? 2 : 1) * 3 ** index;
+        return value;
+    };
+    for (let assignment = 0; assignment < 2 ** conditions.length; assignment += 1) {
+        const encoded = { value: 0 };
+        const outcome = evaluate(node, assignment, encoded);
+        vectors.add(encoded.value * 2 + (outcome ? 1 : 0));
+    }
+    return vectors.size;
+}
+function markDecisionLogicalNodes(node, decisions) {
+    if (t.isLogicalExpression(node) &&
+        (node.operator === "&&" || node.operator === "||")) {
+        decisions.add(node);
+        markDecisionLogicalNodes(node.left, decisions);
+        markDecisionLogicalNodes(node.right, decisions);
+        return;
+    }
+    if (t.isUnaryExpression(node, { operator: "!" }) &&
+        hasCompoundBooleanDecision(node.argument))
+        markDecisionLogicalNodes(node.argument, decisions);
+}
+function hasNestedCoverageSurface(node) {
+    let found = false;
+    const visit = (candidate) => {
+        if (found)
+            return;
+        if (t.isLogicalExpression(candidate) ||
+            t.isConditionalExpression(candidate) ||
+            t.isOptionalMemberExpression(candidate) ||
+            t.isOptionalCallExpression(candidate) ||
+            t.isFunction(candidate) ||
+            t.isClassExpression(candidate) ||
+            (t.isAssignmentExpression(candidate) &&
+                ["&&=", "||=", "??="].includes(candidate.operator))) {
+            found = true;
+            return;
+        }
+        for (const key of t.VISITOR_KEYS[candidate.type] ?? []) {
+            const child = candidate[key];
+            if (Array.isArray(child)) {
+                for (const item of child)
+                    if (item && typeof item === "object" && "type" in item)
+                        visit(item);
+            }
+            else if (child && typeof child === "object" && "type" in child) {
+                visit(child);
+            }
+        }
+    };
+    visit(node);
+    return found;
+}
+function isCoverageTransparentDecision(conditions) {
+    return conditions.every((condition) => !hasNestedCoverageSurface(condition));
+}
 function instrumentConditions(node, frameId, nextIndex, decisionLogicalNodes, conditionRuntimeName) {
     if (t.isLogicalExpression(node) &&
         (node.operator === "&&" || node.operator === "||")) {
@@ -83,7 +191,38 @@ function instrumentConditions(node, frameId, nextIndex, decisionLogicalNodes, co
         node,
     ]);
 }
-function hitStatement(id, hitRuntimeName) {
+function instrumentConditionsV2(node, frameId, conditionTemps, nextIndex, decisionLogicalNodes) {
+    if (t.isLogicalExpression(node) &&
+        (node.operator === "&&" || node.operator === "||")) {
+        const logical = t.logicalExpression(node.operator, instrumentConditionsV2(node.left, frameId, conditionTemps, nextIndex, decisionLogicalNodes), instrumentConditionsV2(node.right, frameId, conditionTemps, nextIndex, decisionLogicalNodes));
+        decisionLogicalNodes.add(logical);
+        return logical;
+    }
+    if (t.isUnaryExpression(node, { operator: "!" }) &&
+        hasCompoundBooleanDecision(node.argument)) {
+        return t.unaryExpression("!", instrumentConditionsV2(node.argument, frameId, conditionTemps, nextIndex, decisionLogicalNodes), true);
+    }
+    const index = nextIndex.value;
+    nextIndex.value += 1;
+    const temporary = conditionTemps[index];
+    const weight = 3 ** index;
+    return t.sequenceExpression([
+        t.assignmentExpression("=", t.cloneNode(temporary), node),
+        t.assignmentExpression("+=", t.cloneNode(frameId), t.conditionalExpression(t.cloneNode(temporary), t.numericLiteral(weight * 2), t.numericLiteral(weight))),
+        t.cloneNode(temporary),
+    ]);
+}
+function hitStatement(id, hitRuntimeName, v2) {
+    if (v2) {
+        const fileState = t.cloneNode(v2.fileState);
+        const clock = t.cloneNode(v2.clock);
+        return t.expressionStatement(t.logicalExpression("||", t.binaryExpression("===", t.memberExpression(t.cloneNode(v2.hitEpochs), t.numericLiteral(v2.pointIndex), true), v2.epoch
+            ? t.cloneNode(v2.epoch)
+            : t.memberExpression(t.cloneNode(clock), t.identifier("epoch"))), t.callExpression(t.identifier(hitRuntimeName), [
+            t.cloneNode(fileState),
+            t.numericLiteral(v2.pointIndex),
+        ])));
+    }
     return t.expressionStatement(t.callExpression(t.identifier(hitRuntimeName), [t.stringLiteral(id)]));
 }
 function allocatedRuntimeNames(code) {
@@ -92,11 +231,23 @@ function allocatedRuntimeNames(code) {
         CONDITION,
         END,
         HIT,
+        REGISTER_V2,
+        END_V2,
+        HIT_V2,
+        FILE_V2,
+        CLOCK_V2,
+        HITS_V2,
+        DECISIONS_V2,
+        COMPLETE_V2,
         SELECTION_BEGIN,
         SELECTION_RIGHT,
         SELECTION_END,
         WITH_REQUEST_PHASE,
         OPTIONAL_SELECT,
+        OPTIONAL_CALL_BEGIN,
+        OPTIONAL_CALL_REACHED,
+        OPTIONAL_CALL_CONTINUED,
+        OPTIONAL_CALL_END,
         DEFAULT_SELECTED,
         DEFAULT_ENTERED,
         TRY_BEGIN,
@@ -143,6 +294,16 @@ function isExecutableStatement(node) {
     }
     return !("declare" in node && node.declare === true);
 }
+function executablePointNode(node) {
+    if (t.isExportNamedDeclaration(node) || t.isExportDefaultDeclaration(node)) {
+        const declaration = node.declaration;
+        return declaration && t.isStatement(declaration) &&
+            isExecutableStatement(declaration)
+            ? declaration
+            : undefined;
+    }
+    return isExecutableStatement(node) ? node : undefined;
+}
 function isAnonymousFunctionDefinition(node) {
     return (t.isArrowFunctionExpression(node) ||
         (t.isFunctionExpression(node) && node.id === null) ||
@@ -214,17 +375,33 @@ function isInsideFunctionParameter(path) {
     }
     return false;
 }
-export function instrumentMcdc(code, file) {
+/** Number encoding remains exact while both 3^n and its doubled outcome index are safe. */
+export const PROBE_V2_MAX_CONDITIONS = 32;
+export const PROBE_V2_DENSE_CONDITION_LIMIT = 6;
+export function instrumentMcdc(code, file, options = {}) {
     const names = allocatedRuntimeNames(code);
     const BEGIN = names["__supercovMcdcBegin"];
     const CONDITION = names["__supercovMcdcCondition"];
     const END = names["__supercovMcdcEnd"];
     const HIT = names["__supercovCoverageHit"];
+    const REGISTER_V2 = names["__supercovRegisterProbeV2"];
+    const END_V2 = names["__supercovMcdcEndV2"];
+    const HIT_V2 = names["__supercovCoverageHitV2"];
+    const FILE_V2 = names["__supercovProbeFileV2"];
+    const CLOCK_V2 = names["__supercovProbeClockV2"];
+    const HITS_V2 = names["__supercovProbeHitsV2"];
+    const DECISIONS_V2 = names["__supercovProbeDecisionsV2"];
+    const COMPLETE_V2 = names["__supercovProbeCompleteV2"];
+    const probeVersion = options.probeVersion ?? 1;
     const SELECTION_BEGIN = names["__supercovSelectionBegin"];
     const SELECTION_RIGHT = names["__supercovSelectionRight"];
     const SELECTION_END = names["__supercovSelectionEnd"];
     const WITH_REQUEST_PHASE = names["__supercovWithRequestPhase"];
     const OPTIONAL_SELECT = names["__supercovOptionalSelect"];
+    const OPTIONAL_CALL_BEGIN = names["__supercovOptionalCallBegin"];
+    const OPTIONAL_CALL_REACHED = names["__supercovOptionalCallReached"];
+    const OPTIONAL_CALL_CONTINUED = names["__supercovOptionalCallContinued"];
+    const OPTIONAL_CALL_END = names["__supercovOptionalCallEnd"];
     const DEFAULT_SELECTED = names["__supercovDefaultSelected"];
     const DEFAULT_ENTERED = names["__supercovDefaultEntered"];
     const TRY_BEGIN = names["__supercovTryBegin"];
@@ -246,6 +423,7 @@ export function instrumentMcdc(code, file) {
         plugins: parserPlugins,
     });
     const decisions = [];
+    const decisionVectorCounts = [];
     const points = [];
     const branches = [];
     const limitations = [];
@@ -292,28 +470,103 @@ export function instrumentMcdc(code, file) {
         },
     });
     const isUnsafeInstrumentationContext = (path) => isWithinSourceSensitiveFunction(path) || isInsideWithStatement(path);
+    // A synchronous function cannot suspend while its body is executing. A
+    // nested coverage scope restores the caller's epoch before returning, so
+    // interior probes can compare against one scalar captured at entry instead
+    // of repeatedly loading the shared clock object. Async functions and
+    // generators deliberately keep the shared clock: either may resume under a
+    // later attribution epoch. Parameter initializers also use the shared clock
+    // because they execute before this body-local declaration.
+    const functionEpochs = new WeakMap();
+    const functionDecisionCaches = new WeakMap();
+    const decisionCacheDeclarations = [];
+    if (probeVersion === 2) {
+        traverse(ast, {
+            Function(path) {
+                const node = path.node;
+                if (node.async ||
+                    node.generator ||
+                    !t.isBlockStatement(node.body) ||
+                    isUnsafeInstrumentationContext(path))
+                    return;
+                const epoch = path.scope.generateUidIdentifier("supercovEpoch");
+                const declaration = t.variableDeclaration("const", [
+                    t.variableDeclarator(t.cloneNode(epoch), t.memberExpression(t.identifier(CLOCK_V2), t.identifier("epoch"))),
+                ]);
+                generatedStatements.add(declaration);
+                node.body.body.unshift(declaration);
+                functionEpochs.set(node, epoch);
+            },
+        });
+    }
+    const functionOwnerForPath = (path) => {
+        const owner = path.findParent((parent) => parent.isFunction());
+        return owner?.isFunction() ? owner : undefined;
+    };
+    const epochForPath = (path) => {
+        const owner = functionOwnerForPath(path);
+        return owner ? functionEpochs.get(owner.node) : undefined;
+    };
+    const localDecisionForPath = (path) => {
+        const owner = functionOwnerForPath(path);
+        if (!owner ||
+            !functionEpochs.has(owner.node) ||
+            !t.isBlockStatement(owner.node.body))
+            return undefined;
+        let cache = functionDecisionCaches.get(owner.node);
+        if (!cache) {
+            cache = {
+                bits: owner.scope.generateUidIdentifier("supercovComplete"),
+                next: 0,
+            };
+            functionDecisionCaches.set(owner.node, cache);
+            decisionCacheDeclarations.push({
+                body: owner.node.body,
+                bits: cache.bits,
+            });
+        }
+        const bit = cache.next++;
+        return bit < 30 ? { bits: cache.bits, mask: 2 ** bit } : undefined;
+    };
     // Record executable statements before adding any instrumentation statements.
+    const instrumentedStatements = new WeakSet();
     traverse(ast, {
         Statement(path) {
             const node = path.node;
-            if (!node.loc ||
+            if (instrumentedStatements.has(node))
+                return;
+            if ((path.parentPath.isExportNamedDeclaration() ||
+                path.parentPath.isExportDefaultDeclaration()) &&
+                path.parentPath.node.declaration === node)
+                return;
+            const pointNode = executablePointNode(node);
+            if (!pointNode?.loc ||
                 isUnsafeInstrumentationContext(path) ||
                 generatedStatements.has(node) ||
-                !isExecutableStatement(node))
+                !isExecutableStatement(pointNode))
                 return;
             if (path.parentPath.isLabeledStatement())
                 return;
-            const id = stableId(file, "statement", node);
+            const id = stableId(file, "statement", pointNode);
             points.push({
                 id,
                 kind: "statement",
                 file,
-                line: node.loc.start.line,
-                column: node.loc.start.column + 1,
-                source: sourceFor(code, node),
+                line: pointNode.loc.start.line,
+                column: pointNode.loc.start.column + 1,
+                source: sourceFor(code, pointNode),
             });
-            const probe = hitStatement(id, HIT);
+            const probe = hitStatement(id, probeVersion === 2 ? HIT_V2 : HIT, probeVersion === 2
+                ? {
+                    fileState: t.identifier(FILE_V2),
+                    clock: t.identifier(CLOCK_V2),
+                    hitEpochs: t.identifier(HITS_V2),
+                    pointIndex: points.length - 1,
+                    epoch: epochForPath(path),
+                }
+                : undefined);
             generatedStatements.add(probe);
+            instrumentedStatements.add(node);
             if (path.parentPath.isProgram() ||
                 path.parentPath.isBlockStatement() ||
                 path.parentPath.isSwitchCase()) {
@@ -327,7 +580,6 @@ export function instrumentMcdc(code, file) {
                 path.key === "consequent" ||
                 path.key === "alternate") {
                 path.replaceWith(t.blockStatement([probe, node]));
-                path.skip();
             }
         },
     });
@@ -367,47 +619,109 @@ export function instrumentMcdc(code, file) {
                 return;
             path.node.object = instrumentOptionalOperand(path, path.node.object);
         },
+    });
+    const optionalCallChains = new Map();
+    traverse(ast, {
         OptionalCallExpression(path) {
-            if (isUnsafeInstrumentationContext(path))
-                return;
-            if (!path.node.optional || !t.isExpression(path.node.callee))
+            if (isUnsafeInstrumentationContext(path) ||
+                !path.node.optional ||
+                !path.node.loc ||
+                !t.isExpression(path.node.callee))
                 return;
             const callee = path.node.callee;
-            if (t.isOptionalMemberExpression(callee)) {
-                if (path.node.loc) {
-                    limitations.push({
-                        id: stableId(file, "semantic-safety", path.node, "optional-chain-call"),
-                        kind: "semantic-safety",
-                        file,
-                        line: path.node.loc.start.line,
-                        column: path.node.loc.start.column + 1,
-                        source: sourceFor(code, path.node),
-                        reason: "optional calls whose receiver is itself an optional chain are left native to preserve chain short-circuiting and method receiver semantics",
-                    });
-                }
-                return;
-            }
-            if (t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) {
-                // Rewriting `object.method?.()` through `.call` preserves `this` for
-                // the immediate invocation but breaks the specification's optional
-                // chain continuation (`object.method?.()()`). Leave it native until a
-                // probe can preserve the chain's internal short-circuit target.
-                if (path.node.loc) {
-                    limitations.push({
-                        id: stableId(file, "semantic-safety", path.node, "optional-method-call"),
-                        kind: "semantic-safety",
-                        file,
-                        line: path.node.loc.start.line,
-                        column: path.node.loc.start.column + 1,
-                        source: sourceFor(code, path.node),
-                        reason: "optional method calls are left native to preserve receiver and whole-chain short-circuit semantics",
-                    });
-                }
+            if (t.isOptionalMemberExpression(callee) &&
+                t.isPrivateName(callee.property)) {
+                limitations.push({
+                    id: stableId(file, "semantic-safety", path.node, "optional-private-call"),
+                    kind: "semantic-safety",
+                    file,
+                    line: path.node.loc.start.line,
+                    column: path.node.loc.start.column + 1,
+                    source: sourceFor(code, path.node),
+                    reason: "optional private-method calls are left native because private names cannot be wrapped as computed reference keys",
+                });
                 return;
             }
-            path.node.callee = instrumentOptionalOperand(path, callee);
+            let root = path;
+            while ((root.parentPath.isOptionalCallExpression() &&
+                root.parentPath.node.callee === root.node) ||
+                (root.parentPath.isOptionalMemberExpression() &&
+                    root.parentPath.node.object === root.node))
+                root = root.parentPath;
+            if (root.parentPath.isUnaryExpression({ operator: "delete" }) &&
+                root.parentPath.node.argument === root.node)
+                root = root.parentPath;
+            const id = stableId(file, "optional-chain", path.node, "call");
+            const shortId = `${id}:short`;
+            const continuedId = `${id}:continued`;
+            branches.push({
+                id,
+                kind: "optional-chain",
+                file,
+                line: path.node.loc.start.line,
+                column: path.node.loc.start.column + 1,
+                source: sourceFor(code, path.node),
+                alternatives: [
+                    { id: shortId, label: "nullish / short-circuited" },
+                    { id: continuedId, label: "non-nullish / continued" },
+                ],
+            });
+            const chain = optionalCallChains.get(root.node) ?? {
+                path: root,
+                sites: [],
+            };
+            chain.sites.push({
+                node: path.node,
+                frame: root.scope.generateUidIdentifier("optionalCall"),
+                shortId,
+                continuedId,
+            });
+            optionalCallChains.set(root.node, chain);
         },
     });
+    for (const chain of optionalCallChains.values()) {
+        for (const site of chain.sites) {
+            chain.path.scope.push({ id: t.cloneNode(site.frame), kind: "let" });
+            const callee = site.node.callee;
+            if (t.isMemberExpression(callee) ||
+                t.isOptionalMemberExpression(callee)) {
+                if (t.isPrivateName(callee.property)) {
+                    if (t.isExpression(callee.object))
+                        callee.object = t.callExpression(t.identifier(OPTIONAL_CALL_REACHED), [t.cloneNode(site.frame), callee.object]);
+                    site.node.arguments.unshift(t.spreadElement(t.callExpression(t.identifier(OPTIONAL_CALL_CONTINUED), [
+                        t.cloneNode(site.frame),
+                    ])));
+                    continue;
+                }
+                const property = callee.computed
+                    ? callee.property
+                    : t.isIdentifier(callee.property)
+                        ? t.stringLiteral(callee.property.name)
+                        : callee.property;
+                callee.computed = true;
+                callee.property = t.callExpression(t.identifier(OPTIONAL_CALL_REACHED), [t.cloneNode(site.frame), property]);
+            }
+            else {
+                site.node.callee = t.callExpression(t.identifier(OPTIONAL_CALL_REACHED), [t.cloneNode(site.frame), callee]);
+            }
+            site.node.arguments.unshift(t.spreadElement(t.callExpression(t.identifier(OPTIONAL_CALL_CONTINUED), [
+                t.cloneNode(site.frame),
+            ])));
+        }
+        let measured = chain.path.node;
+        for (const site of [...chain.sites].reverse())
+            measured = t.callExpression(t.identifier(OPTIONAL_CALL_END), [
+                t.cloneNode(site.frame),
+                measured,
+            ]);
+        chain.path.replaceWith(t.sequenceExpression([
+            ...chain.sites.map((site) => t.assignmentExpression("=", t.cloneNode(site.frame), t.callExpression(t.identifier(OPTIONAL_CALL_BEGIN), [
+                t.stringLiteral(site.shortId),
+                t.stringLiteral(site.continuedId),
+            ]))),
+            measured,
+        ]));
+    }
     // Logical assignments have the same short/right split as value-selection
     // expressions, but wrapping only the RHS preserves one-time LHS evaluation.
     traverse(ast, {
@@ -470,8 +784,6 @@ export function instrumentMcdc(code, file) {
         Function(path) {
             if (isUnsafeInstrumentationContext(path))
                 return;
-            if (!t.isBlockStatement(path.node.body))
-                return;
             const entries = [];
             const visitPattern = (pattern) => {
                 if (t.isTSParameterProperty(pattern)) {
@@ -530,7 +842,19 @@ export function instrumentMcdc(code, file) {
             };
             for (const parameter of path.node.params)
                 visitPattern(parameter);
-            path.node.body.body.unshift(...entries);
+            if (entries.length === 0)
+                return;
+            if (t.isBlockStatement(path.node.body)) {
+                path.node.body.body.unshift(...entries);
+                return;
+            }
+            if (!path.isArrowFunctionExpression())
+                throw new Error("Only arrow functions may have expression bodies");
+            const value = path.node.body;
+            path.node.body = t.blockStatement([
+                ...entries,
+                t.returnStatement(value),
+            ]);
         },
     });
     // Destructuring declarations use the same token protocol. For loop-binding
@@ -631,6 +955,8 @@ export function instrumentMcdc(code, file) {
     });
     // Try/catch and enumeration loops use frames finalized in `finally`, so
     // return, break, continue, rejection, and throw paths remain observable.
+    const tryTargets = new WeakMap();
+    const enumerationTargets = new WeakMap();
     traverse(ast, {
         TryStatement(path) {
             if (isUnsafeInstrumentationContext(path))
@@ -653,23 +979,7 @@ export function instrumentMcdc(code, file) {
                     { id: catchId, label: "catch entered" },
                 ],
             });
-            const frameId = path.scope.generateUidIdentifier("supercovTryFrame");
-            const frameScope = path.scope.getFunctionParent() ?? path.scope.getProgramParent();
-            frameScope.push({ id: t.cloneNode(frameId), kind: "let" });
-            path.insertBefore(t.expressionStatement(t.assignmentExpression("=", t.cloneNode(frameId), t.callExpression(t.identifier(TRY_BEGIN), [
-                t.stringLiteral(successId),
-                t.stringLiteral(catchId),
-            ]))));
-            node.handler.body.body.unshift(t.expressionStatement(t.callExpression(t.identifier(TRY_CATCH), [
-                t.cloneNode(frameId),
-                t.identifier("undefined"),
-            ])));
-            const end = t.expressionStatement(t.callExpression(t.identifier(TRY_END), [t.cloneNode(frameId)]));
-            if (node.finalizer)
-                node.finalizer.body.unshift(end);
-            else
-                node.finalizer = t.blockStatement([end]);
-            path.skip();
+            tryTargets.set(node, { successId, catchId });
         },
         "ForInStatement|ForOfStatement"(path) {
             if (isUnsafeInstrumentationContext(path))
@@ -693,39 +1003,86 @@ export function instrumentMcdc(code, file) {
                     { id: enteredId, label: "one or more iterations" },
                 ],
             });
-            const frameId = path.scope.generateUidIdentifier("supercovLoopFrame");
-            const frameScope = path.scope.getFunctionParent() ?? path.scope.getProgramParent();
-            frameScope.push({ id: t.cloneNode(frameId), kind: "let" });
-            const assignment = t.expressionStatement(t.assignmentExpression("=", t.cloneNode(frameId), t.callExpression(t.identifier(LOOP_BEGIN), [
-                t.stringLiteral(zeroId),
-                t.stringLiteral(enteredId),
-            ])));
-            const loop = t.cloneNode(node, true);
-            loop.body = t.isBlockStatement(loop.body)
-                ? loop.body
-                : t.blockStatement([loop.body]);
-            loop.body.body.unshift(t.expressionStatement(t.callExpression(t.identifier(LOOP_ENTERED), [
-                t.cloneNode(frameId),
-            ])));
-            let loopStatement = loop;
-            let replacementPath = path;
-            while (replacementPath.parentPath?.isLabeledStatement() &&
-                replacementPath.parentPath.node.body === replacementPath.node) {
-                loopStatement = t.labeledStatement(t.cloneNode(replacementPath.parentPath.node.label), loopStatement);
-                replacementPath = replacementPath.parentPath;
-            }
-            const wrapped = t.tryStatement(t.blockStatement([loopStatement]), null, t.blockStatement([
-                t.expressionStatement(t.callExpression(t.identifier(LOOP_END), [t.cloneNode(frameId)])),
-            ]));
-            if (replacementPath === path) {
-                path.insertBefore(assignment);
-                path.replaceWith(wrapped);
+            enumerationTargets.set(node, { zeroId, enteredId });
+        },
+    });
+    // Transform bottom-up after the denominator is frozen. This keeps nested
+    // try/loop nodes attached to the tree while they are rewritten; mutating an
+    // outer path first can leave a nested Babel path detached while still
+    // recording an obligation that can never emit evidence.
+    traverse(ast, {
+        TryStatement: {
+            exit(path) {
+                if (isUnsafeInstrumentationContext(path))
+                    return;
+                const node = path.node;
+                const target = tryTargets.get(node);
+                if (!target || !node.handler)
+                    return;
+                const frameId = path.scope.generateUidIdentifier("supercovTryFrame");
+                const frameScope = path.scope.getFunctionParent() ?? path.scope.getProgramParent();
+                frameScope.push({ id: t.cloneNode(frameId), kind: "let" });
+                path.insertBefore(t.expressionStatement(t.assignmentExpression("=", t.cloneNode(frameId), t.callExpression(t.identifier(TRY_BEGIN), [
+                    t.stringLiteral(target.successId),
+                    t.stringLiteral(target.catchId),
+                ]))));
+                node.handler.body.body.unshift(t.expressionStatement(t.callExpression(t.identifier(TRY_CATCH), [
+                    t.cloneNode(frameId),
+                    t.identifier("undefined"),
+                ])));
+                const end = t.expressionStatement(t.callExpression(t.identifier(TRY_END), [t.cloneNode(frameId)]));
+                if (node.finalizer)
+                    node.finalizer.body.unshift(end);
+                else
+                    node.finalizer = t.blockStatement([end]);
                 path.skip();
-            }
-            else {
-                replacementPath.replaceWith(t.blockStatement([assignment, wrapped]));
-                replacementPath.skip();
-            }
+            },
+        },
+        "ForInStatement|ForOfStatement": {
+            exit(path) {
+                if (isUnsafeInstrumentationContext(path))
+                    return;
+                const node = path.node;
+                const target = enumerationTargets.get(node);
+                if (!target)
+                    return;
+                const frameId = path.scope.generateUidIdentifier("supercovLoopFrame");
+                const frameScope = path.scope.getFunctionParent() ?? path.scope.getProgramParent();
+                frameScope.push({ id: t.cloneNode(frameId), kind: "let" });
+                const assignment = t.expressionStatement(t.assignmentExpression("=", t.cloneNode(frameId), t.callExpression(t.identifier(LOOP_BEGIN), [
+                    t.stringLiteral(target.zeroId),
+                    t.stringLiteral(target.enteredId),
+                ])));
+                const loop = t.cloneNode(node, true);
+                restoreClonedOffsets(node, loop);
+                loop.body = t.isBlockStatement(loop.body)
+                    ? loop.body
+                    : t.blockStatement([loop.body]);
+                loop.body.body.unshift(t.expressionStatement(probeVersion === 2
+                    ? t.assignmentExpression("=", t.memberExpression(t.cloneNode(frameId), t.identifier("entered")), t.booleanLiteral(true))
+                    : t.callExpression(t.identifier(LOOP_ENTERED), [
+                        t.cloneNode(frameId),
+                    ])));
+                let loopStatement = loop;
+                let replacementPath = path;
+                while (replacementPath.parentPath?.isLabeledStatement() &&
+                    replacementPath.parentPath.node.body === replacementPath.node) {
+                    loopStatement = t.labeledStatement(t.cloneNode(replacementPath.parentPath.node.label), loopStatement);
+                    replacementPath = replacementPath.parentPath;
+                }
+                const wrapped = t.tryStatement(t.blockStatement([loopStatement]), null, t.blockStatement([
+                    t.expressionStatement(t.callExpression(t.identifier(LOOP_END), [t.cloneNode(frameId)])),
+                ]));
+                if (replacementPath === path) {
+                    path.insertBefore(assignment);
+                    path.replaceWith(wrapped);
+                    path.skip();
+                }
+                else {
+                    replacementPath.replaceWith(t.blockStatement([assignment, wrapped]));
+                    replacementPath.skip();
+                }
+            },
         },
     });
     // Function entry is separate from statement coverage so empty functions and
@@ -747,7 +1104,14 @@ export function instrumentMcdc(code, file) {
                 source: sourceFor(code, node),
                 ...(functionLabel(path) ? { label: functionLabel(path) } : {}),
             });
-            const probe = hitStatement(id, HIT);
+            const probe = hitStatement(id, probeVersion === 2 ? HIT_V2 : HIT, probeVersion === 2
+                ? {
+                    fileState: t.identifier(FILE_V2),
+                    clock: t.identifier(CLOCK_V2),
+                    hitEpochs: t.identifier(HITS_V2),
+                    pointIndex: points.length - 1,
+                }
+                : undefined);
             generatedStatements.add(probe);
             if (t.isBlockStatement(node.body)) {
                 node.body.body.unshift(probe);
@@ -774,6 +1138,7 @@ export function instrumentMcdc(code, file) {
             conditions: originalConditions.map((condition) => sourceFor(code, condition)),
             kind,
         };
+        const decisionIndex = decisions.length;
         decisions.push(meta);
         // A loop predicate's path scope may be represented by Babel as the loop
         // body's block. Declaring the frame there puts it after the predicate that
@@ -786,29 +1151,99 @@ export function instrumentMcdc(code, file) {
             path.scope.parent
             ? path.scope.parent
             : path.scope;
-        const frameScope = evaluationScope.getFunctionParent() ??
-            evaluationScope.getProgramParent();
+        const frameScope = evaluationScope.getFunctionParent() ?? evaluationScope.getProgramParent();
         const frameId = frameScope.generateUidIdentifier("supercovMcdcFrame");
-        if (!inlineFrame)
+        const useV2 = probeVersion === 2 &&
+            originalConditions.length <= PROBE_V2_MAX_CONDITIONS;
+        const conditionTemps = useV2
+            ? originalConditions.map(() => frameScope.generateUidIdentifier("supercovMcdcValue"))
+            : [];
+        const resultTemp = useV2
+            ? frameScope.generateUidIdentifier("supercovMcdcResult")
+            : undefined;
+        const useDenseV2 = useV2 && originalConditions.length <= PROBE_V2_DENSE_CONDITION_LIMIT;
+        const useSaturatedV2 = useDenseV2 && isCoverageTransparentDecision(originalConditions);
+        const originalDecision = useSaturatedV2
+            ? t.cloneNode(path.node, true)
+            : undefined;
+        if (originalDecision)
+            markDecisionLogicalNodes(originalDecision, decisionLogicalNodes);
+        decisionVectorCounts.push(useSaturatedV2
+            ? probeV2ReachableVectorCount(path.node, originalConditions)
+            : 0);
+        const decisionEpoch = inlineFrame ? undefined : epochForPath(path);
+        const localComplete = useSaturatedV2 && !inlineFrame ? localDecisionForPath(path) : undefined;
+        const vectorTemp = useDenseV2
+            ? frameScope.generateUidIdentifier("supercovMcdcVector")
+            : undefined;
+        if (!inlineFrame) {
             frameScope.push({ id: t.cloneNode(frameId), kind: "let" });
-        const instrumented = instrumentConditions(path.node, frameId, { value: 0 }, decisionLogicalNodes, CONDITION);
+            for (const temporary of conditionTemps)
+                frameScope.push({ id: t.cloneNode(temporary), kind: "let" });
+            if (resultTemp)
+                frameScope.push({ id: t.cloneNode(resultTemp), kind: "let" });
+            if (vectorTemp)
+                frameScope.push({ id: t.cloneNode(vectorTemp), kind: "let" });
+        }
+        const instrumented = useV2
+            ? instrumentConditionsV2(path.node, frameId, conditionTemps, { value: 0 }, decisionLogicalNodes)
+            : instrumentConditions(path.node, frameId, { value: 0 }, decisionLogicalNodes, CONDITION);
         const begin = t.callExpression(t.identifier(BEGIN), [
             t.stringLiteral(id),
             t.valueToNode(meta),
         ]);
-        const assignFrame = t.assignmentExpression("=", t.cloneNode(frameId), begin);
-        const end = t.callExpression(t.identifier(END), [
-            t.cloneNode(frameId),
-            instrumented,
-        ]);
-        path.replaceWith(inlineFrame
+        const assignFrame = t.assignmentExpression("=", t.cloneNode(frameId), useV2 ? t.numericLiteral(0) : begin);
+        const end = useV2
+            ? t.callExpression(t.identifier(END_V2), [
+                t.identifier(FILE_V2),
+                t.numericLiteral(decisionIndex),
+                t.cloneNode(frameId),
+                t.cloneNode(resultTemp),
+            ])
+            : t.callExpression(t.identifier(END), [
+                t.cloneNode(frameId),
+                instrumented,
+            ]);
+        const v2Tail = useV2
+            ? [
+                t.assignmentExpression("=", t.cloneNode(resultTemp), instrumented),
+                ...(useDenseV2
+                    ? [
+                        t.assignmentExpression("=", t.cloneNode(vectorTemp), t.binaryExpression("+", t.binaryExpression("*", t.cloneNode(frameId), t.numericLiteral(2)), t.conditionalExpression(t.cloneNode(resultTemp), t.numericLiteral(1), t.numericLiteral(0)))),
+                        t.logicalExpression("||", t.binaryExpression("===", t.memberExpression(t.memberExpression(t.identifier(DECISIONS_V2), t.numericLiteral(decisionIndex), true), t.cloneNode(vectorTemp), true), decisionEpoch
+                            ? t.cloneNode(decisionEpoch)
+                            : t.memberExpression(t.identifier(CLOCK_V2), t.identifier("epoch"))), end),
+                        t.cloneNode(resultTemp),
+                    ]
+                    : [end]),
+            ]
+            : [end];
+        const observedDecision = inlineFrame
             ? t.callExpression(t.arrowFunctionExpression([], t.blockStatement([
                 t.variableDeclaration("let", [
-                    t.variableDeclarator(t.cloneNode(frameId), begin),
+                    t.variableDeclarator(t.cloneNode(frameId), useV2 ? t.numericLiteral(0) : begin),
+                    ...conditionTemps.map((temporary) => t.variableDeclarator(t.cloneNode(temporary))),
+                    ...(resultTemp
+                        ? [t.variableDeclarator(t.cloneNode(resultTemp))]
+                        : []),
+                    ...(vectorTemp
+                        ? [t.variableDeclarator(t.cloneNode(vectorTemp))]
+                        : []),
                 ]),
-                t.returnStatement(end),
+                t.returnStatement(useV2 ? t.sequenceExpression(v2Tail) : end),
             ])), [])
-            : t.sequenceExpression([assignFrame, end]));
+            : t.sequenceExpression([assignFrame, ...(useV2 ? v2Tail : [end])]);
+        const completeCheck = useSaturatedV2
+            ? t.binaryExpression("===", t.memberExpression(t.identifier(COMPLETE_V2), t.numericLiteral(decisionIndex), true), decisionEpoch
+                ? t.cloneNode(decisionEpoch)
+                : t.memberExpression(t.identifier(CLOCK_V2), t.identifier("epoch")))
+            : undefined;
+        const completeFastPath = completeCheck && localComplete
+            ? t.logicalExpression("||", t.binaryExpression("!==", t.binaryExpression("&", t.cloneNode(localComplete.bits), t.numericLiteral(localComplete.mask)), t.numericLiteral(0)), t.logicalExpression("&&", completeCheck, t.assignmentExpression("|=", t.cloneNode(localComplete.bits), t.numericLiteral(localComplete.mask))))
+            : completeCheck;
+        path.replaceWith(useSaturatedV2
+            ? t.conditionalExpression(completeFastPath, originalDecision, observedDecision)
+            : observedDecision);
         path.skip();
     };
     traverse(ast, {
@@ -1088,14 +1523,17 @@ export function instrumentMcdc(code, file) {
             if (isUnsafeInstrumentationContext(path))
                 return;
             const callee = path.node.callee;
-            const property = (t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) &&
+            const property = (t.isMemberExpression(callee) ||
+                t.isOptionalMemberExpression(callee)) &&
                 !callee.computed &&
                 t.isIdentifier(callee.property)
                 ? callee.property.name
                 : undefined;
             const identifier = t.isIdentifier(callee) ? callee.name : property;
             let callbackIndex = -1;
-            if ((property === "on" || property === "once" || property === "addListener") &&
+            if ((property === "on" ||
+                property === "once" ||
+                property === "addListener") &&
                 t.isStringLiteral(path.node.arguments[0]) &&
                 ["request", "upgrade", "connection"].includes(path.node.arguments[0].value)) {
                 callbackIndex = 1;
@@ -1124,6 +1562,13 @@ export function instrumentMcdc(code, file) {
             usesRequestPhaseHandler = true;
         },
     });
+    // Decision cache identifiers are discovered during instrumentation. Insert
+    // their declarations only after all source traversals so no live NodePath is
+    // shifted while a source statement is being rewritten.
+    for (const { body, bits } of decisionCacheDeclarations)
+        body.body.unshift(t.variableDeclaration("let", [
+            t.variableDeclarator(t.cloneNode(bits), t.numericLiteral(0)),
+        ]));
     const manifest = {
         decisions,
         points,
@@ -1139,10 +1584,21 @@ export function instrumentMcdc(code, file) {
             t.importSpecifier(t.identifier(CONDITION), t.identifier("mcdcCondition")),
             t.importSpecifier(t.identifier(END), t.identifier("mcdcEnd")),
             t.importSpecifier(t.identifier(HIT), t.identifier("coverageHit")),
+            ...(probeVersion === 2
+                ? [
+                    t.importSpecifier(t.identifier(REGISTER_V2), t.identifier("registerProbeV2")),
+                    t.importSpecifier(t.identifier(END_V2), t.identifier("mcdcEndV2")),
+                    t.importSpecifier(t.identifier(HIT_V2), t.identifier("coverageHitV2")),
+                ]
+                : []),
             t.importSpecifier(t.identifier(SELECTION_BEGIN), t.identifier("selectionBegin")),
             t.importSpecifier(t.identifier(SELECTION_RIGHT), t.identifier("selectionRight")),
             t.importSpecifier(t.identifier(SELECTION_END), t.identifier("selectionEnd")),
             t.importSpecifier(t.identifier(OPTIONAL_SELECT), t.identifier("optionalSelect")),
+            t.importSpecifier(t.identifier(OPTIONAL_CALL_BEGIN), t.identifier("optionalCallBegin")),
+            t.importSpecifier(t.identifier(OPTIONAL_CALL_REACHED), t.identifier("optionalCallReached")),
+            t.importSpecifier(t.identifier(OPTIONAL_CALL_CONTINUED), t.identifier("optionalCallContinued")),
+            t.importSpecifier(t.identifier(OPTIONAL_CALL_END), t.identifier("optionalCallEnd")),
             t.importSpecifier(t.identifier(DEFAULT_SELECTED), t.identifier("defaultSelected")),
             t.importSpecifier(t.identifier(DEFAULT_ENTERED), t.identifier("defaultEntered")),
             t.importSpecifier(t.identifier(TRY_BEGIN), t.identifier("tryBegin")),
@@ -1156,7 +1612,23 @@ export function instrumentMcdc(code, file) {
                     t.importSpecifier(t.identifier(WITH_REQUEST_PHASE), t.identifier("withRequestPhase")),
                 ]
                 : []),
-        ], t.stringLiteral(RUNTIME_MODULE)));
+        ], t.stringLiteral(RUNTIME_MODULE)), ...(probeVersion === 2
+            ? [
+                t.variableDeclaration("const", [
+                    t.variableDeclarator(t.identifier(FILE_V2), t.callExpression(t.identifier(REGISTER_V2), [
+                        t.valueToNode({
+                            decisions,
+                            pointIds: points.map((point) => point.id),
+                            decisionVectorCounts,
+                        }),
+                    ])),
+                    t.variableDeclarator(t.identifier(CLOCK_V2), t.memberExpression(t.identifier(FILE_V2), t.identifier("clock"))),
+                    t.variableDeclarator(t.identifier(HITS_V2), t.memberExpression(t.identifier(FILE_V2), t.identifier("hitEpochs"))),
+                    t.variableDeclarator(t.identifier(DECISIONS_V2), t.memberExpression(t.identifier(FILE_V2), t.identifier("decisionEpochs"))),
+                    t.variableDeclarator(t.identifier(COMPLETE_V2), t.memberExpression(t.identifier(FILE_V2), t.identifier("decisionCompleteEpochs"))),
+                ]),
+            ]
+            : []));
     }
     const output = generate({
         ...ast,