supercov 0.0.43 → 0.0.45

package/runtime/javascript/runnerEvidence.mjs

@@ -27,13 +27,24 @@ function localFile(file) {
     return relative(process.cwd(), absolute).split(sep).join("/");
 }
 export function runnerTestId(identity) {
-    const key = [
+    const parts = [
         identity.runner,
         localFile(identity.file) ?? "unknown",
         identity.line ?? 0,
         identity.column ?? 0,
         identity.name,
-    ].join("\0");
+    ];
+    // Preserve existing top-level, uniquely registered test IDs. Nested tests
+    // and repeated registrations need more than a shared source/name identity.
+    if (identity.parentTestId)
+        parts.push("parent", identity.parentTestId);
+    if (identity.registrationOrdinal)
+        parts.push("registration", identity.registrationOrdinal);
+    // Titles can themselves contain separator text. Domain-separate and encode
+    // the extended identity structurally so it cannot alias a literal title.
+    const key = identity.parentTestId || identity.registrationOrdinal
+        ? JSON.stringify(["registration-v2", ...parts])
+        : parts.join("\0");
     return `${identity.runner}:${createHash("sha256").update(key).digest("hex").slice(0, 24)}`;
 }
 export function runnerExecutionScope(identity) {
@@ -50,24 +61,35 @@ export function runnerExecutionScope(identity) {
         testId,
         testKey,
         retry,
-        attemptId: `${testKey}-${retry}`,
+        // Different processes/worker threads can execute the same registration.
+        // Their files must not collide even though the stable test ID is shared.
+        attemptId: `${testKey}-${retry}-${processInstanceToken()}`,
     };
 }
-export function callerLocation(ignored) {
-    const lines = new Error().stack?.split("\n").slice(2) ?? [];
-    for (const entry of lines) {
-        if (ignored.test(entry) || entry.includes("node:internal"))
-            continue;
-        const match = /(?:\(|at\s+)(file:\/\/[^:)]+|(?:[A-Za-z]:)?[^():]+):(\d+):(\d+)\)?$/.exec(entry.trim());
+export function callerLocation(boundary = callerLocation) {
+    // Omit the registration wrapper by identity. A user file may have the same
+    // basename as a runtime adapter. Parse the location suffix, not individual
+    // path segments: spaces, parentheses and Unicode are valid filenames.
+    try {
+        const error = {};
+        Error.captureStackTrace(error, boundary);
+        if (typeof error.stack !== "string")
+            return {};
+        const entry = error.stack.split("\n")[1]?.trim();
+        const match = entry && /(?:^at (?:async )?| \()((?:file:\/\/|\/|[A-Za-z]:[\\/]|\\\\).*):(\d+):(\d+)\)?$/.exec(entry);
         if (!match)
-            continue;
+            return {};
         return {
             file: match[1],
             line: Number(match[2]),
             column: Number(match[3]),
         };
     }
-    return {};
+    catch {
+        // Custom formatters must not prevent registration. Missing provenance
+        // is explicit, never replaced with an unrelated deeper caller.
+        return {};
+    }
 }
 export function readScopedServerEvidence(scope, evidencePath = serverEvidencePath(scope)) {
     try {

package/runtime/javascript/runtime.mjs

@@ -144,9 +144,6 @@ function createState() {
     decisions: /* @__PURE__ */ new Map(),
     hits: /* @__PURE__ */ new Set(),
     events: [],
-    // Position of the test-file statement currently executing ("file:line:column"), set by the
-    // instrumented test module; production hits recorded meanwhile are attributed to it.
-    testStatement: void 0,
     // Per value-position logical expression (`a && b`, `a || b`, `a ?? b`): the distinct
     // (right operand evaluated?, result truthy?) pairs seen, keyed by branch id.
     logicals: /* @__PURE__ */ new Map(),
@@ -317,7 +314,6 @@ function resetCoverage(testId2) {
   state.decisions.clear();
   state.hits.clear();
   state.events.length = 0;
-  state.testStatement = void 0;
   state.logicals.clear();
   state.eventKeys.clear();
   state.probeV2ContextEpochs.clear();
@@ -721,9 +717,11 @@ function withCoverageCarrier(carrier, callback) {
 function assertionPhaseState(scope) {
   const key = attemptKey(scope);
   const existing = state.assertionPhases.get(key);
-  if (existing)
+  if (existing) {
+    existing.phaseIds ??= new Set(existing.phases.filter(phase => phase.kind === "assertion").map(phase => phase.id));
     return existing;
-  const created = { counter: 0, phases: [] };
+  }
+  const created = { counter: 0, phases: [], phaseIds: new Set() };
   state.assertionPhases.set(key, created);
   return created;
 }
@@ -753,9 +751,13 @@ function withNodeAssertionPhase(operation, source, callback) {
   const scope = context.scope;
   if (!scope)
     return callback();
-  const existing = context.phaseId ? assertionPhaseState(scope).phases.find((phase2) => phase2.id === context.phaseId && phase2.kind === "assertion") : void 0;
+  const existing = context.phaseId && assertionPhaseState(scope).phaseIds.has(context.phaseId);
   if (existing)
     return callback();
+  // A lexical occurrence already identifies its source. Stack fallback is lazy
+  // and qualified so transformed coordinates cannot impersonate original ones.
+  if (typeof source === "function")
+    source = source();
   const bridged = (_a8 = runtimeGlobal.__SUPERCOV_ASSERTION_PHASE_BRIDGE__) == null ? void 0 : _a8.call(runtimeGlobal, operation, source, callback);
   if (bridged == null ? void 0 : bridged.handled)
     return bridged.value;
@@ -768,6 +770,7 @@ function withNodeAssertionPhase(operation, source, callback) {
     startedAtMs: Date.now()
   });
   attempt.phases.push(phase);
+  attempt.phaseIds.add(phase.id);
   try {
     const result = withCoverageCarrier({ version: 1, scope, phaseId: phase.id }, callback);
     if (result && typeof result.then === "function")
@@ -785,6 +788,13 @@ function withNodeAssertionPhase(operation, source, callback) {
     throw cleanInstrumentationStack(error);
   }
 }
+// Callee binding preserves receiver, getter/evaluation order, spreads and the
+// original await/yield placement. Only the matcher call opens the phase.
+function bindNodeAssertionPhase(operation, source, target, property = null) {
+  const callback = property === null ? target : target[property];
+  const receiver = property === null ? undefined : target;
+  return (...args) => withNodeAssertionPhase(operation, source, () => Reflect.apply(callback, receiver, args));
+}
 function takeNodeAssertionPhases(scope) {
   var _a8, _b;
   const key = attemptKey(scope);
@@ -978,31 +988,25 @@ function recordBrowserEvent(event) {
   state.events.push(event);
   return true;
 }
-function testStatement(source) {
-  state.testStatement = typeof source === "string" && source.length > 0 ? source : void 0;
-}
-function statementFields() {
-  return state.testStatement ? { statementId: state.testStatement } : {};
-}
 function coverageHit(id) {
   state.hits.add(id);
   const timestampMs = Date.now();
   const phaseId = currentPhaseId();
   if (isBrowser) {
-    if (recordBrowserEvent(__spreadProps(__spreadValues(__spreadValues({
+    if (recordBrowserEvent(__spreadProps(__spreadValues({
       type: "hit",
       id,
       timestampMs
-    }, phaseId ? { phaseId } : {}), statementFields()), {
+    }, phaseId ? { phaseId } : {}), {
       environment: "browser"
     })))
       persistBrowser();
   } else {
-    appendServer(__spreadValues(__spreadValues({
+    appendServer(__spreadValues({
       type: "hit",
       id,
       timestampMs
-    }, phaseId ? { phaseId } : {}), statementFields()));
+    }, phaseId ? { phaseId } : {}));
   }
 }
 function registerProbeV2(definition) {
@@ -1237,22 +1241,22 @@ function mcdcEnd(frame, value) {
   const timestampMs = Date.now();
   const phaseId = currentPhaseId();
   if (isBrowser) {
-    if (recordBrowserEvent(__spreadProps(__spreadValues(__spreadValues({
+    if (recordBrowserEvent(__spreadProps(__spreadValues({
       type: "decision",
       id: decision.meta.id,
       vector,
       timestampMs
-    }, phaseId ? { phaseId } : {}), statementFields()), {
+    }, phaseId ? { phaseId } : {}), {
       environment: "browser"
     })))
       persistBrowser();
   } else {
-    appendServer(__spreadValues(__spreadValues({
+    appendServer(__spreadValues({
       type: "decision",
       meta: decision.meta,
       vector,
       timestampMs
-    }, phaseId ? { phaseId } : {}), statementFields()));
+    }, phaseId ? { phaseId } : {}));
   }
   return value;
 }
@@ -1293,12 +1297,12 @@ const directRuntimeApi = {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
-  testStatement,
   tryBegin,
   tryCatch,
   tryEnd,
   withCoverageCarrier,
   withNodeAssertionPhase,
+  bindNodeAssertionPhase,
   withRequestPhase,
   writeExclusiveBackgroundRecord
 };
@@ -1343,12 +1347,12 @@ export {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
-  testStatement,
   tryBegin,
   tryCatch,
   tryEnd,
   withCoverageCarrier,
   withNodeAssertionPhase,
+  bindNodeAssertionPhase,
   withRequestPhase,
   writeExclusiveBackgroundRecord
 };

package/schemas/assertions.schema.json

@@ -0,0 +1,276 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "AssertionMap",
+  "type": "object",
+  "properties": {
+    "schemaVersion": {
+      "type": "integer",
+      "format": "uint32",
+      "minimum": 2,
+      "maximum": 2
+    },
+    "assertions": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/Assertion"
+      }
+    },
+    "changeAssessments": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/ChangeAssessment"
+      }
+    },
+    "retiredAssertions": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/Retired"
+      }
+    }
+  },
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "assertions"
+  ],
+  "$defs": {
+    "Assertion": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "at": {
+          "$ref": "#/$defs/Anchor"
+        },
+        "questions": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "observes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": []
+        },
+        "flows": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Flow"
+          },
+          "default": []
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "at"
+      ]
+    },
+    "Anchor": {
+      "description": "One-based lines and UTF-8 byte columns, for every language. Text is exact.",
+      "type": "object",
+      "properties": {
+        "file": {
+          "type": "string"
+        },
+        "line": {
+          "type": "integer",
+          "format": "uint",
+          "minimum": 0
+        },
+        "column": {
+          "type": "integer",
+          "format": "uint",
+          "minimum": 0
+        },
+        "text": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "file",
+        "line",
+        "column",
+        "text"
+      ]
+    },
+    "Flow": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "basis": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "pattern": "^scov2:[0-9a-f]{64}$"
+        },
+        "explanation": {
+          "type": "string"
+        },
+        "appliesTo": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/TestSelector"
+          }
+        },
+        "nodes": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Node"
+          }
+        },
+        "edges": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Edge"
+          },
+          "default": []
+        },
+        "countsAsAsserted": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "watch": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "questions": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "basis",
+        "explanation",
+        "appliesTo",
+        "nodes",
+        "countsAsAsserted",
+        "watch"
+      ]
+    },
+    "TestSelector": {
+      "type": "object",
+      "properties": {
+        "file": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "file",
+        "name"
+      ]
+    },
+    "Node": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "at": {
+          "$ref": "#/$defs/Anchor"
+        },
+        "role": {
+          "type": "string"
+        },
+        "meaning": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "at"
+      ]
+    },
+    "Edge": {
+      "type": "object",
+      "properties": {
+        "from": {
+          "type": "string"
+        },
+        "to": {
+          "type": "string"
+        },
+        "kind": {
+          "type": "string"
+        },
+        "basis": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "from",
+        "to",
+        "kind"
+      ]
+    },
+    "ChangeAssessment": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "basis": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "pattern": "^scov2:[0-9a-f]{64}$"
+        },
+        "affectedFlows": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "explanation": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "basis",
+        "affectedFlows",
+        "explanation"
+      ]
+    },
+    "Retired": {
+      "type": "object",
+      "properties": {
+        "assertion": {
+          "$ref": "#/$defs/Assertion"
+        },
+        "reason": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "assertion",
+        "reason"
+      ]
+    }
+  }
+}

package/analyzers/typescript/README.md

@@ -1,55 +0,0 @@
-# JS/TS assertion analyzer (internal)
-
-This private package is the post-run analysis component used by Supercov's
-`runs <run> assertions` command. It is bundled in the npm distribution, not
-published as a separate CLI or SDK.
-
-See [Assertion evidence](../../docs/assertion-evidence.md) for public commands,
-pragma syntax, report interpretation and supported scope.
-
-## Product boundary
-
-- `bin/query.mjs` is the CLI-to-analyzer JSON transport. It accepts an ordinary
-  archive representation prepared by Rust, validates identities and returns facts.
-- `bin/identity.mjs` checks the analyzer source/build identity; its direct
-  invocation writes that identity during the build.
-- `bin/compiler-identity.mjs` fingerprints the project's compiler implementation.
-- `src/archive.ts` validates the archive protocol, source positions and attempt
-  ownership, then constructs query-local evidence in memory.
-- `src/analyze.ts` extracts source-flow facts and exact assertion witnesses.
-  The Rust engine joins those facts into candidate classifications.
-- `src/frontend.ts` and `src/native-frontend.ts` implement the legacy and native
-  TypeScript compiler boundaries. `src/pragmas.ts` validates optional hints.
-
-There is no converted-input command, on-disk research input, V8 remapping,
-mutation runner or diagnostic-ablation option in the product interface.
-Source files ship to support build-identity verification; tests and research
-tools do not ship. Assertion candidates remain unverified, not safety proofs.
-Only executable JavaScript and its build identity ship from `dist`; there is no
-public SDK declaration surface or generated source-map payload.
-
-## Build and test
-
-From this directory:
-
-```sh
-npm ci --ignore-scripts
-npm test
-```
-
-The build uses pinned TypeScript 5.8.3 explicitly. Project analysis uses the
-project's compiler; native 7.0.2 has a separate frontend and identity checks.
-Native compiler processes close after both successful and failed queries.
-
-From the repository root, exercise real Node/Vitest archives and the installed
-npm package:
-
-```sh
-npm run test:asserted-integration
-npm run test:asserted-package
-```
-
-Controlled unit fixtures test parser, flow and witness rules. The ordinary-archive
-integration tests execute real suites and explicit behavioral counterexamples.
-Compiler-path and identity regressions run across supported CI platforms.
-Historical external-cohort research is not part of the default suite or product.

package/analyzers/typescript/bin/compiler-identity.mjs

@@ -1,78 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFileSync, readdirSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import { projectCompilerPath } from "../dist/compiler.js";
-
-/** Hash the native implementation as well as its JS client; version.cjs alone is not the compiler. */
-export function compilerIdentity(projectRoot) {
-  return compilerIdentityFromEntry(projectCompilerPath(projectRoot));
-}
-
-export function compilerIdentityFromEntry(entry) {
-  const require = createRequire(pathToFileURL(entry));
-  const { version } = require(entry);
-  const entrySha256 = createHash("sha256")
-    .update(readFileSync(entry))
-    .digest("hex");
-  if (version !== "7.0.2")
-    return { backend: "typescript-legacy", version, sha256: entrySha256 };
-  const packageRoot = dirname(require.resolve("typescript/package.json"));
-  const platform = `@typescript/typescript-${process.platform}-${process.arch}`;
-  let nativeRoot;
-  try {
-    nativeRoot = dirname(require.resolve(`${platform}/package.json`));
-  } catch (cause) {
-    throw new Error(
-      `TypeScript 7's native compiler dependency ${platform} is missing. Install the project's optional TypeScript dependencies before recapturing tests.`,
-      { cause },
-    );
-  }
-  const nativeMetadata = JSON.parse(
-    readFileSync(resolve(nativeRoot, "package.json"), "utf8"),
-  );
-  if (nativeMetadata.name !== platform || nativeMetadata.version !== version)
-    throw new Error(
-      `TypeScript native package identity mismatch: expected ${platform}@${version}`,
-    );
-  const executable = resolve(
-    nativeRoot,
-    "lib",
-    process.platform === "win32" ? "tsc.exe" : "tsc",
-  );
-  const nativeSha256 = createHash("sha256")
-    .update(readFileSync(executable))
-    .digest("hex");
-  const hash = createHash("sha256");
-  let files = 0;
-  function walk(root, relative = "") {
-    for (const file of readdirSync(resolve(root, relative), {
-      withFileTypes: true,
-    }).sort((a, b) => a.name.localeCompare(b.name))) {
-      if (file.name === "node_modules") continue;
-      const path = relative ? `${relative}/${file.name}` : file.name;
-      if (file.isDirectory()) walk(root, path);
-      else if (file.isFile()) {
-        hash
-          .update(path)
-          .update("\0")
-          .update(readFileSync(resolve(root, path)))
-          .update("\0");
-        files++;
-      } else throw new Error(`Unsupported compiler package entry: ${path}`);
-    }
-  }
-  hash.update("typescript-package\0");
-  walk(packageRoot);
-  hash.update("native-package\0");
-  walk(nativeRoot);
-  return {
-    backend: "typescript-native-7",
-    version,
-    sha256: hash.digest("hex"),
-    nativePackage: platform,
-    nativeSha256,
-    files,
-  };
-}