supercov 0.0.44 → 0.0.46

package/runtime/javascript/runnerEvidence.mjs

@@ -36,13 +36,15 @@ export function runnerTestId(identity) {
     ];
     // Preserve existing top-level, uniquely registered test IDs. Nested tests
     // and repeated registrations need more than a shared source/name identity.
+    if (identity.role === "setup")
+        parts.push("role", "setup");
     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
+    const key = identity.role === "setup" || identity.parentTestId || identity.registrationOrdinal
         ? JSON.stringify(["registration-v2", ...parts])
         : parts.join("\0");
     return `${identity.runner}:${createHash("sha256").update(key).digest("hex").slice(0, 24)}`;
@@ -116,6 +118,7 @@ export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOv
         title: identity.name.split(" > ").at(-1) ?? identity.name,
         retry: identity.retry ?? 0,
         status,
+        ...(identity.role ? { role: identity.role } : {}),
         provenance: inferTestProvenance({
             runner: identity.runner,
             file: testFile,

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;
@@ -970,15 +963,56 @@ function requestCoverageContext(value) {
   const phaseId = typeof rawPhaseId === "string" && rawPhaseId.length > 0 && (!scope || phaseBelongsToAttempt(rawPhaseId, scope.attemptId)) ? rawPhaseId : void 0;
   return __spreadValues(__spreadValues({}, scope ? { scope } : {}), phaseId ? { phaseId } : {});
 }
-function withRequestPhase(handler) {
+// Keep connection ownership on the emitter, without changing listener
+// identity (removeListener/off and once still see the original callbacks).
+const emitterContextMaps = runtimeGlobal.__SUPERCOV_EMITTER_CONTEXT_MAPS__ ??= new Map();
+const emitterCoverageContexts = emitterContextMaps.get(runtimeInstance) ?? new WeakMap();
+emitterContextMaps.set(runtimeInstance, emitterCoverageContexts);
+const patchedEmitterInstances = runtimeGlobal.__SUPERCOV_EMITTER_PATCHED_INSTANCES__ ??= new Set();
+function installNodeRequestPropagation() {
+  if (isBrowser || patchedEmitterInstances.has(runtimeInstance) || typeof process === "undefined") return;
+  const EventEmitter = process.getBuiltinModule?.("node:events")?.EventEmitter;
+  const Server = process.getBuiltinModule?.("node:http")?.Server;
+  const SecureServer = process.getBuiltinModule?.("node:https")?.Server;
+  if (!EventEmitter) return;
+  const original = EventEmitter.prototype.emit;
+  EventEmitter.prototype.emit = function(event, ...args) {
+    let context = emitterCoverageContexts.get(this);
+    if ((event === "request" || event === "upgrade") &&
+        ((Server && this instanceof Server) || (SecureServer && this instanceof SecureServer))) {
+      // HTTP headers establish ownership even when Express/SDK listeners and
+      // the server process were created by a shared before hook.
+      const incoming = requestCoverageContext(args[0]);
+      if (incoming) context = incoming.scope ? incoming : context ?? currentRequestContext();
+    }
+    const invoke = () => Reflect.apply(original, this, [event, ...args]);
+    try {
+      return context ? withCoverageCarrier({ version: 1, ...context }, invoke) : invoke();
+    } finally {
+      if (event === "close") emitterCoverageContexts.delete(this);
+    }
+  };
+  patchedEmitterInstances.add(runtimeInstance);
+}
+installNodeRequestPropagation();
+
+function withRequestPhase(handler, event) {
   if (!serverPhaseStorage)
     return handler;
+  const registeredContext = currentRequestContext();
   return function coverageRequestPhase(...args) {
     var _a8, _b, _c, _d;
     const requestContext = args.map((argument) => requestCoverageContext(argument)).find((context2) => context2 !== void 0);
-    const inheritedContext = requestContext === void 0 ? currentRequestContext() : {};
+    // An untagged request to a test-owned server must not erase that server's
+    // owner. Shared servers have no captured test scope and stay unattributed.
+    const inheritedContext = requestContext?.scope ? {} : registeredContext.scope ? registeredContext : requestContext === void 0 ? currentRequestContext() : {};
     const context = __spreadValues(__spreadValues({}, ((_a8 = requestContext == null ? void 0 : requestContext.scope) != null ? _a8 : inheritedContext.scope) ? { scope: (_b = requestContext == null ? void 0 : requestContext.scope) != null ? _b : inheritedContext.scope } : {}), ((_c = requestContext == null ? void 0 : requestContext.phaseId) != null ? _c : inheritedContext.phaseId) ? { phaseId: (_d = requestContext == null ? void 0 : requestContext.phaseId) != null ? _d : inheritedContext.phaseId } : {});
-    const invoke = () => Reflect.apply(handler, this, args);
+    const invoke = () => {
+      if (event === "connection" && context.scope && args[0] &&
+          typeof args[0] === "object" && typeof args[0].emit === "function")
+        emitterCoverageContexts.set(args[0], context);
+      return Reflect.apply(handler, this, args);
+    };
     return requestContext !== void 0 || context.scope || context.phaseId ? serverPhaseStorage.run(context, () => withProbeV2Context(context, invoke)) : invoke();
   };
 }
@@ -995,31 +1029,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 +1282,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 +1338,12 @@ const directRuntimeApi = {
   selectionEnd,
   selectionRight,
   takeNodeAssertionPhases,
-  bindNodeAssertion,
-  testStatement,
   tryBegin,
   tryCatch,
   tryEnd,
   withCoverageCarrier,
   withNodeAssertionPhase,
+  bindNodeAssertionPhase,
   withRequestPhase,
   writeExclusiveBackgroundRecord
 };
@@ -1361,13 +1388,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,
-  };
-}