supercov 0.0.44 → 0.0.45

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();
@@ -758,8 +754,8 @@ function withNodeAssertionPhase(operation, source, callback) {
   const existing = context.phaseId && assertionPhaseState(scope).phaseIds.has(context.phaseId);
   if (existing)
     return callback();
-  // The adapter's stack is only a fallback. Avoid formatting it when a lexical
-  // probe already supplied the active phase's exact original-source identity.
+  // 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);
@@ -792,15 +788,12 @@ function withNodeAssertionPhase(operation, source, callback) {
     throw cleanInstrumentationStack(error);
   }
 }
-// Resolve the target exactly once, before argument evaluation, just like a
-// native call reference. The closure carries only source identity and receiver;
-// it never captures an assertion phase or mutable current-statement state across
-// await. Rejected arguments therefore create no phase, and awaited producer work
-// is not retroactively attributed to the assertion invocation.
-function bindNodeAssertion(operation, source, receiver, method) {
-  const target = method === void 0 ? receiver : receiver[method];
-  const thisArgument = method === void 0 ? void 0 : receiver;
-  return (...args) => withNodeAssertionPhase(operation, source, () => Reflect.apply(target, thisArgument, args));
+// 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;
@@ -995,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) {
@@ -1254,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;
 }
@@ -1310,13 +1297,12 @@ const directRuntimeApi = {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
-  bindNodeAssertion,
-  testStatement,
   tryBegin,
   tryCatch,
   tryEnd,
   withCoverageCarrier,
   withNodeAssertionPhase,
+  bindNodeAssertionPhase,
   withRequestPhase,
   writeExclusiveBackgroundRecord
 };
@@ -1361,13 +1347,12 @@ export {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
-  bindNodeAssertion,
-  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,59 +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/mock-counts.ts` models bounded synchronous console-mock count histories,
-  keeping count evidence separate from general value-protection claims.
-- `src/awaited-observations.ts` recognizes bounded native child-capture/poll
-  source patterns for hint attachment, without manufacturing runtime witnesses.
-- `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,
-  };
-}

package/analyzers/typescript/bin/identity.mjs

@@ -1,71 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const root = resolve(import.meta.dirname, "..");
-const sources = [
-  "src/analyze.ts",
-  "src/archive.ts",
-  "src/awaited-observations.ts",
-  "src/compiler.ts",
-  "src/frontend.ts",
-  "src/native-frontend.ts",
-  "src/types.ts",
-  "src/pragmas.ts",
-  "src/mock-counts.ts",
-  "bin/query.mjs",
-  "bin/compiler-identity.mjs",
-  "bin/identity.mjs",
-  "tsconfig.json",
-  // npm excludes package-lock.json from tarballs. Hash shipped build inputs,
-  // not a checkout-only file, so installed and development checks are identical.
-  "package.json",
-];
-const outputs = [
-  "dist/analyze.js",
-  "dist/archive.js",
-  "dist/awaited-observations.js",
-  "dist/compiler.js",
-  "dist/frontend.js",
-  "dist/native-frontend.js",
-  "dist/types.js",
-  "dist/pragmas.js",
-  "dist/mock-counts.js",
-];
-function digest(files) {
-  const hash = createHash("sha256");
-  for (const file of files)
-    hash
-      .update(file)
-      .update("\0")
-      .update(readFileSync(resolve(root, file)))
-      .update("\0");
-  return hash.digest("hex");
-}
-export function identity() {
-  return {
-    schema: 1,
-    sourceSha256: digest(sources),
-    compiledSha256: digest(outputs),
-  };
-}
-export function checkedIdentity() {
-  const built = JSON.parse(
-    readFileSync(resolve(root, "dist/build-identity.json"), "utf8"),
-  );
-  const current = identity();
-  if (JSON.stringify(built) !== JSON.stringify(current))
-    throw new Error(
-      "Assertion analyzer build is stale or modified; rebuild analyzers/typescript",
-    );
-  return current;
-}
-if (
-  process.argv[1] &&
-  resolve(process.argv[1]) === fileURLToPath(import.meta.url)
-)
-  writeFileSync(
-    resolve(root, "dist/build-identity.json"),
-    JSON.stringify(identity()) + "\n",
-  );

package/analyzers/typescript/bin/query.mjs

@@ -1,29 +0,0 @@
-// First-party query transport, never executed by the test runner.
-import { readFileSync } from "node:fs";
-import { checkedIdentity } from "./identity.mjs";
-
-try {
-  const analyzer = checkedIdentity();
-  const input = JSON.parse(readFileSync(0, "utf8"));
-  // Check the build before importing executable analyzer code.
-  const { compilerIdentity } = await import("./compiler-identity.mjs");
-  const { analyzeArchive } = await import("../dist/archive.js");
-  const compiler = compilerIdentity(input.projectRoot);
-  const compilerSha256 = compiler.sha256;
-  const result = analyzeArchive(input);
-  if (
-    JSON.stringify(compilerIdentity(input.projectRoot)) !==
-      JSON.stringify(compiler) ||
-    JSON.stringify(checkedIdentity()) !== JSON.stringify(analyzer)
-  )
-    throw new Error("Analyzer or compiler changed during analysis");
-  process.stdout.write(
-    JSON.stringify({
-      ...result,
-      analyzer: { ...analyzer, compilerSha256, compiler },
-    }),
-  );
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exitCode = 1;
-}