supercov 0.0.44 → 0.0.46

package/docs/supported-suites.md

@@ -45,7 +45,7 @@ Supercov reports the level it actually observed. It does not guess.
 | --- | --- |
 | Playwright | Exact per test, worker, retry, outcome, action, and assertion phase |
 | Vitest | Exact per test, with setup execution kept separate |
-| Jest | Exact per test, including parameterized tests, with the user's own configuration, setup files and reporters kept; `expect` assertions link the evidence they check |
+| Jest | Exact per test, including parameterized tests, with the user's own configuration, setup files and reporters kept; passing `expect` occurrences are identified for assertion maps |
 | `node:test` | Exact per test |
 | AVA and Mocha | Aggregate structural coverage |
 | Other Node-based runners | Aggregate when their processes remain visible to Supercov |
@@ -63,19 +63,15 @@ TypeScript, and TSX are supported.
 Supercov instruments an isolated copy. It does not ask you to add an import,
 reporter, plugin, or alternate build output.
 
-A suite that runs its own compiled output is built before the tests start.
-Supercov reads the tests: one that imports from `dist/`, or launches a package
-script that does—`spawn("npm", ["run", "start"])`, `execSync("npm run
-start")`, or any launch handed to the shell as one string—means the build is
-part of the run, and a `build` script is run inside the isolated copy first.
-Without it the server under test would never exist. A launch that only names a
-build subcommand, such as `vite build`, is not taken as consuming a build.
+If tests import compiled output such as `dist/` or launch a script that uses it,
+Supercov runs the project's build inside the isolated copy before testing.
+Keep using your normal test and build commands. Instrumentation does not
+require changing the project's TypeScript settings.
 
-Instrumented TypeScript is exempt from the host's type policy whether the
-compile is Supercov's own build step or the test command's own `tsc`.
-Instrumentation necessarily rewrites control-flow expressions in ways a type
-checker cannot narrow through, so a project that compiles inside its test
-command builds under measurement exactly as it does without it.
+For assertion maps, Node, Vitest, Jest and Playwright's Node-side assertions
+supply supported passing-occurrence evidence. Custom assertion wrappers and
+browser-side checks can have additional observation limits. See
+[Assertion evidence](assertion-evidence.md) before interpreting a missing occurrence.
 
 ### Browsers, servers, and child processes
 
@@ -114,22 +110,16 @@ whatever was still buffered.
 | cargo-nextest | Exact test, attempt, retry, and binary identity | cargo-nextest 0.9.138 or 0.9.140 |
 
 Supercov preserves Cargo's test selection, scheduling, fail-fast behavior,
-environment, and exit status. Doctests are measured like any other test:
-Supercov stands in for rustdoc during `cargo test --doc`, runs each doctest
-in its own process, and attributes what it executed to that doctest by name.
-With nextest, Supercov is nextest's target runner, so nextest's own
-scheduling, retries and output stay as they are and each attempt is recorded
-separately. The measured source is what rustc compiles: every crate root and
-the modules it reaches through `mod` declarations, `#[path]` attributes and
-literal `include!` calls; a `.rs` file nothing declares as a module, such as
-one embedded with `include_str!`, is left untouched. Statements, functions,
-`if`/`while`/match-guard decisions with their conditions (let chains
-included), match arms, `&&` and `||`, `for` and `while` loops and the `?`
-operator each take a probe; what a thread recorded before it passed an
-`assert!`, `assert_eq!` or `assert_ne!` is linked to that assertion, so the
-report can separate code a test checked from code it merely ran; const contexts and macro expansions stay in the
-denominator behind an explicit limitation. Use the repository's normal flags after the
-wrapped command:
+environment and exit status. Doctests run with their own identities; nextest
+retries remain separate attempts.
+
+Measured source follows the modules rustc compiles, including `#[path]` and
+literal `include!` calls. Undeclared `.rs` files are not treated as application
+modules. Statements, functions, branches, boolean decisions, loops and error
+propagation are measured. Const contexts and macro expansions remain visible
+with explicit measurement limitations.
+
+Use the repository's normal flags after the wrapped command:
 
 ```sh
 npx supercov -- cargo test --workspace
@@ -149,35 +139,22 @@ attribution.
 | pytest-rerunfailures | Exact per attempt; flaky tests are reported as such | |
 | `python -m unittest` | Exact test and setUp/test/tearDown phase identity | Serial in-process; skips and expected failures are recorded; subtest failures roll up to the parent test |
 
-Evidence a test records before its first assertion is linked to that assertion
-when the test passes, so a line reads "linked to a passing assertion" rather
-than "execution only". Under pytest this covers plain `assert` statements,
-through pytest's assertion-pass hook, which Supercov turns on for a rewrite
-cache of its own so plain runs keep theirs, and `pytest.raises` and
-`pytest.warns` blocks; every `unittest` `assert*` method counts under both
-runners. What a test runs after its first assertion is execution only.
-
-Supercov measures Python through CPython's own monitoring interface. Nothing is
-copied, rewritten, or compiled differently: the project runs in place with its
-own interpreter and virtual environment, and Supercov only adds a start-up hook
-through `PYTHONPATH`, a pytest plugin through `PYTEST_PLUGINS`, one pytest
-option (`enable_assertion_pass_hook`) through `PYTEST_ADDOPTS`, and a few
-`SUPERCOV_*` variables. Child interpreters started with `subprocess` or
-`multiprocessing` inherit the exact test identity; threads and thread pools
-carry it through `contextvars`.
-
-Each interpreter writes commit-framed evidence to a process-owned mmap. A hard
-kill preserves completed observations and an incomplete tail is ignored; an
-exhausted transport or corrupt committed frame fails the run closed.
-
-Measured obligations are statements (including several on one line), function
-entry, boolean decisions with MC/DC vectors, `for` and comprehension iteration,
-`and`/`or` short-circuiting, `match` case selection, and `try` completion,
-handler selection and exception propagation, all derived from CPython's own
-instruction positions rather than from exception hooks.
-
-Interpreters launched with `-I`, `-E`, or `-S` ignore `PYTHONPATH` and are not
-measured. Code compiled from strings at runtime has no source obligations.
+Your project runs in place with its own interpreter and virtual environment.
+Supercov adds its monitoring and runner hooks through the process environment;
+you do not need to rewrite tests or configure a different build.
+
+Coverage includes statements, functions, boolean decisions, loops,
+comprehensions, short-circuit operators, `match` cases and exception paths.
+Child interpreters, threads and thread pools can retain the calling test's
+identity. The report also distinguishes execution before a passing assertion
+from later execution. These phase records alone do not prove which values the
+assertion checks.
+
+Interpreters launched with `-I`, `-E` or `-S` ignore the required startup hook
+and are not measured. Code compiled from strings at runtime has no source
+obligations. Completed observations can survive a hard kill, but a corrupt or
+exhausted evidence channel fails the run rather than reporting partial data as
+complete.
 
 ```sh
 npx supercov -- pytest
@@ -197,95 +174,35 @@ npx supercov -- python -m unittest
 | Thread-parallel Minitest (`parallelize_me!`, `parallelize(with: :threads)`) | Probe observations exact per test; line, method and simple-branch observations made while phases overlapped go to the run, declared | |
 | Cucumber | Exact scenario identity (`features/x.feature:LINE`), hook steps as setup/teardown | `cucumber`, `bundle exec cucumber` |
 
-Evidence a test records before its first assertion is linked to that assertion
-when the test passes: Minitest's `assert`/`refute` family, RSpec's
-`expect(...).to` and `not_to` (in Cucumber steps too) and test-unit's
-assertions all count. What a test runs after its first assertion is execution
-only.
-
-Supercov measures Ruby with Ruby's own `Coverage` module plus probe calls it
-splices into application files in memory as they load. Nothing on disk is
-rewritten or copied; the project runs with its own interpreter and bundle, and
-Supercov only adds a `-r` entry to `RUBYOPT` and a few `SUPERCOV_*` variables.
-No insertion adds a line, so backtraces keep their line numbers.
-
-Measured obligations are statements, method definitions, `if`/`unless`/
-ternary/`while`/`until` decisions with MC/DC vectors over `&&`/`||` operands,
-`while`/`until`/`for` iteration and the idiomatic iterator blocks (`each`,
-`map`, `times`, `select`, ...), `&&`/`||`/`||=`/`&&=` short-circuiting,
-`case`/`when`, `case`/`in` and `&.` selection, and `begin`/`rescue` completion,
-handler selection and propagation. `||=` and `&&=` on method-call, index and
-constant targets are exact too: an arrival probe and a right-side probe count
-the skipped side without re-reading the target. Blocks and lambdas are
-statements inside their methods, not function entry points, and that includes
-a `define_method` block: Ruby's own method coverage reports one entry per
-method it defines, but the block's body is measured statement by statement
-instead of as a definition.
-
-A statement on a line Ruby's own line table never counts (`x = case`, a
-multi-line literal assignment, a bare `begin`, `if false`) gets a probe at load
-time instead.
-
-On Ruby 3.4 and newer, Supercov asks the `Coverage` module for line events
-alone. Each test phase is sampled from `Coverage`, and asking for its branch
-and method tables too made every sample rebuild both for every loaded file,
-gems included, which was most of what a Ruby test suite paid under Supercov.
-Instead, the statement that starts a branch body or a method body proves the
-branch, the method and the decision outcome it witnesses, and what has no such
-statement is probed: an `if` without `else`, a modifier `if`, a ternary, `&.`,
-a `case` without `else`, an empty body. Ruby 3.3 cannot apply probes and keeps
-reading `Coverage`'s branch and method keys.
-`if true`/`if false`/`if nil` and other literal predicates are folded the way
-Ruby folds them: no branch, and the dead arm is not an obligation. Code inside
-a `Ractor.new` block gets no probes: a non-main Ractor cannot read the probe
-receiver, so a probe there would raise where the untouched program ran. Its
-lines are still counted; what only a probe could have proven inside it is
-declared unmeasured at the block. A Spring
-preloader started before the run has no hook and fails closed; JRuby and
-TruffleRuby are not supported.
-
-The runtime loads through `RUBYOPT` before Bundler and requires only
-`coverage`, so it never activates a gem an application's Gemfile pins
-differently. Insertions are checked against Ruby itself by a sweep
-(`scripts/ruby-corpus-sweep.sh`, which drives `scripts/ruby-position-sweep.rb`)
-over Ruby's whole standard library and the Rails, Rack, RSpec, Minitest,
-test-unit and Cucumber gems, about 4,300 files installed once into a stable
-corpus directory: every file is transformed and compiled with its line count
-intact, every branch key Ruby 3.3 reads is compared with what Ruby reports for
-the untouched source, and each file is loaded twice, untouched and
-transformed, so the probes are proven to preserve behaviour and define the
-same methods.
-
-A `begin` whose body ends in an expression that can `return` from inside
-itself has its handlers and propagation measured as usual, but its normal
-completion is declared instead of probed unless every branch of that
-expression can carry the probe: Ruby cannot pass such an expression as an
-argument, which is what a probe wrapper does.
-
-Measuring never breaks the program being measured. If a file cannot be
-compiled with its probes, it loads unmodified: Ruby's `Coverage` still
-measures its lines, methods and own branches, and only the obligations a
-probe would have proven are declared for that file. Setting
-`SUPERCOV_RUBY_SKIP_PROBES` to a comma-separated list of path fragments puts
-chosen files on that same path deliberately, which is the escape hatch if
-instrumentation ever disagrees with one of yours.
-
-Ruby 3.3 does not apply its `Coverage` module to code compiled by a load hook,
-so on 3.3 Supercov measures through `Coverage` alone: lines, methods and the
-branches Ruby reports itself. Everything that needs a probe (multi-condition
-decisions, `||=`, loops, `rescue` flow, a second statement on a line) is
-declared unmeasured on that interpreter rather than shown as a gap. Ruby 3.4
-and newer measure everything.
-
-Ruby reads its own coverage as the interpreter exits, and that shapes what a
-stopped process keeps. A process ended by a signal it can catch—`SIGTERM`
-from a test's teardown, `SIGINT`—unwinds through that exit and reports
-everything it measured. A process killed with `SIGKILL`, or one that leaves
-through `exit!`, never gets there and takes with it whatever it observed since
-its last test boundary. Supercov cannot recover that or say which lines it
-would have been, so the run declares that a process did not report, which
-blocks completeness, rather than counting those lines against the code. Stop a
-Ruby server with `SIGTERM`, or wait for it to exit, and it reports.
+Your project runs in place with its own interpreter and bundle. Supercov loads
+through `RUBYOPT`; application files on disk and their backtrace line numbers
+stay unchanged. RSpec, Minitest and test-unit assertions can identify execution
+before a passing assertion. That timing evidence alone does not show which
+values the assertion checks.
+
+Ruby 3.4 and newer support statement, method, branch and MC/DC measurement,
+including loops, iterator blocks, short-circuit operators, pattern matching,
+optional calls and exception paths. Ruby 3.3 supplies Ruby's own line, method
+and branch coverage; obligations requiring additional instrumentation are
+reported as measurement limits.
+
+Some constructs have narrower coverage. Code in a non-main Ractor keeps line
+coverage but may lack other observations. Certain nested-return expressions
+limit normal-completion measurement. Constant predicates are folded as Ruby
+folds them, so unreachable alternatives do not become obligations.
+
+If a file cannot be instrumented safely, Supercov loads it unchanged and reports
+the remaining limits. To apply that fallback to a known incompatible file, set
+`SUPERCOV_RUBY_SKIP_PROBES` to a comma-separated list of path fragments. This
+reduces measurement; it is not a way to claim that skipped obligations are covered.
+
+A Spring preloader started before the run has no coverage hook. Restart it
+within the measured command. JRuby and TruffleRuby are not supported.
+
+Stop test-owned Ruby servers with `SIGTERM` or wait for normal exit so they can
+report their evidence. `SIGKILL` and `exit!` can lose observations since the last
+test boundary. A process that does not report leaves a measurement limit; its
+missing evidence is not counted as uncovered application code.
 
 ```sh
 npx supercov -- rspec

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "supercov",
-  "version": "0.0.44",
-  "description": "Coverage for coding agents and software factories 🌙",
+  "version": "0.0.46",
+  "description": "Coverage for coding agents and software factories \ud83c\udf19",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -15,22 +15,21 @@
   "files": [
     "bin",
     "runtime/javascript",
-    "docs",
-    "analyzers/typescript/bin",
-    "analyzers/typescript/dist/analyze.js",
-    "analyzers/typescript/dist/mock-counts.js",
-    "analyzers/typescript/dist/archive.js",
-    "analyzers/typescript/dist/awaited-observations.js",
-    "analyzers/typescript/dist/compiler.js",
-    "analyzers/typescript/dist/frontend.js",
-    "analyzers/typescript/dist/native-frontend.js",
-    "analyzers/typescript/dist/pragmas.js",
-    "analyzers/typescript/dist/types.js",
-    "analyzers/typescript/dist/build-identity.json",
-    "analyzers/typescript/src",
-    "analyzers/typescript/package.json",
-    "analyzers/typescript/tsconfig.json",
-    "analyzers/typescript/README.md",
+    "docs/getting-started.md",
+    "docs/agent-loop.md",
+    "docs/assertions.md",
+    "docs/assertion-evidence.md",
+    "docs/assertion-maps.md",
+    "docs/assertion-agent.md",
+    "docs/troubleshooting.md",
+    "docs/cli.md",
+    "docs/coverage-model.md",
+    "docs/evidence.md",
+    "docs/supported-suites.md",
+    "docs/verification.md",
+    "docs/performance.md",
+    "docs/workspace-isolation.md",
+    "schemas",
     "README.md"
   ],
   "engines": {
@@ -49,7 +48,6 @@
   },
   "scripts": {
     "build": "cargo build -p supercov",
-    "build:asserted-typescript": "npm --prefix analyzers/typescript run build",
     "sync:rust-assets": "node scripts/sync-rust-package-assets.mjs",
     "test:rust-assets": "node scripts/sync-rust-package-assets.mjs --check",
     "check:rustc-backend-spike": "(cd spikes/rustc-backend && RUSTC_BOOTSTRAP=1 RUSTUP_TOOLCHAIN=1.95.0 cargo fmt --check && RUSTC_BOOTSTRAP=1 RUSTUP_TOOLCHAIN=1.95.0 cargo clippy --all-targets -- -D warnings)",
@@ -57,11 +55,8 @@
     "test:rust-compiler-spikes": "cargo build -p supercov && node scripts/rust-libtest-companion-spike.mjs && node scripts/rust-async-attribution-spike.mjs && node scripts/rust-subprocess-attribution-spike.mjs && node scripts/rust-custom-harness-spike.mjs && node scripts/rust-libtest-builder-lifecycle-spike.mjs",
     "test": "cargo test --workspace",
     "test:runtime": "node --test tests/runtime/*.test.mjs",
-    "test:asserted-typescript": "npm --prefix analyzers/typescript test",
-    "test:asserted-integration": "cargo build -p supercov && npm --prefix analyzers/typescript run build && SUPERCOV_ASSERTED_INTEGRATION=1 node --test analyzers/typescript/tests/archive.integration.test.mjs",
-    "test:asserted-package": "cargo build -p supercov && npm run build:asserted-typescript && node scripts/asserted-packed-integration.mjs",
     "test:fixture": "cargo build -p supercov && node scripts/rust-fixture-matrix.mjs",
-    "test:packed-npx": "cargo build --release -p supercov && npm run build:asserted-typescript && node scripts/packed-npx-integration.mjs",
+    "test:packed-npx": "cargo build --release -p supercov && node scripts/packed-npx-integration.mjs",
     "test:isolation": "cargo build -p supercov && node scripts/isolation-integration.mjs",
     "test:filesystem": "cargo test --workspace && cargo build -p supercov && node scripts/workspace-crash-integration.mjs",
     "test:watchdog": "cargo build -p supercov && node scripts/watchdog-integration.mjs",
@@ -69,7 +64,7 @@
     "test:agent": "cargo build -p supercov && node scripts/agent-query-eval.mjs",
     "test:engine": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace && cargo build -p supercov && npm run test:runtime && npm run test:rust-assets && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-jest-integration.mjs && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-custom-browser-playwright-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
     "test:platform": "cargo test --workspace && cargo build -p supercov && node scripts/rust-process-supervision.mjs && node scripts/workspace-crash-integration.mjs",
-    "test:native-package": "cargo build --release -p supercov && npm run build:asserted-typescript && node scripts/native-package-integration.mjs && node scripts/native-release-set-integration.mjs",
+    "test:native-package": "cargo build --release -p supercov && node scripts/native-package-integration.mjs && node scripts/native-release-set-integration.mjs",
     "test:pypi-wheel": "node scripts/pypi-wheel-integration.mjs",
     "test:pypi-registry": "node scripts/pypi-registry-integration.mjs",
     "build:rubygem": "cargo build --release -p supercov && node scripts/build-rubygem.mjs",
@@ -80,28 +75,33 @@
     "test:test262": "cargo build --release -p supercov && node scripts/test262-equivalence.mjs",
     "benchmark:check": "cargo build --release -p supercov && node scripts/rust-transform-benchmark.mjs",
     "benchmark:python-monitoring": "cargo build -p supercov && node scripts/python-monitoring-benchmark.mjs",
-    "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:runtime && npm run test:rust-assets && npm run test:asserted-typescript && npm run test:asserted-integration && npm run test:asserted-package && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
+    "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:runtime && npm run test:rust-assets && npm run test:assertion-maps && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
     "release:check": "cargo clean && node scripts/sweep-target.mjs && npm run check && npm run test:engine && npm run test:fixture && npm run test:watchdog && npm run test:engine-contract && npm run test:agent && npm run test:child-attribution && npm run test:host-loader && npm run test:python-monitoring && npm run test:ruby-coverage && npm run test:rust-public-cargo && npm run test:packed-npx && npm run test:clang-mcdc && npm run benchmark:check",
     "release:bump": "node scripts/bump-version.mjs",
     "sweep": "node scripts/sweep-target.mjs",
     "oracle:rust": "cargo build --release -p supercov && node scripts/rust-coverage-oracle.mjs",
-    "prepack": "npm run build:asserted-typescript && node scripts/package-preflight.mjs",
+    "prepack": "node scripts/package-preflight.mjs",
     "prepublishOnly": "npm run release:check",
     "test:child-attribution": "cargo build -p supercov && node scripts/rust-child-attribution-integration.mjs",
     "test:host-loader": "cargo build -p supercov && node scripts/rust-host-loader-integration.mjs",
     "test:python-monitoring": "cargo build -p supercov && node scripts/python-monitoring-integration.mjs",
     "test:ruby-coverage": "cargo build -p supercov && node scripts/ruby-coverage-integration.mjs",
-    "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs"
+    "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs",
+    "test:assertion-maps": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-integration.mjs && node scripts/assertion-map-js-integration.mjs && node scripts/assertion-dogfood-integration.mjs",
+    "test:assertion-maps:js": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-js-integration.mjs && node scripts/assertion-dogfood-integration.mjs",
+    "sync:assertion-schema": "cargo build -p supercov && node scripts/assertion-map-schema.mjs",
+    "docs:sync": "node scripts/sync-docs.mjs",
+    "docs:check": "node scripts/sync-docs.mjs --check"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.44",
-    "@supercov/cli-darwin-x64": "0.0.44",
-    "@supercov/cli-linux-arm64-gnu": "0.0.44",
-    "@supercov/cli-linux-arm64-musl": "0.0.44",
-    "@supercov/cli-linux-x64-gnu": "0.0.44",
-    "@supercov/cli-linux-x64-musl": "0.0.44",
-    "@supercov/cli-win32-arm64": "0.0.44",
-    "@supercov/cli-win32-x64": "0.0.44"
+    "@supercov/cli-darwin-arm64": "0.0.46",
+    "@supercov/cli-darwin-x64": "0.0.46",
+    "@supercov/cli-linux-arm64-gnu": "0.0.46",
+    "@supercov/cli-linux-arm64-musl": "0.0.46",
+    "@supercov/cli-linux-x64-gnu": "0.0.46",
+    "@supercov/cli-linux-x64-musl": "0.0.46",
+    "@supercov/cli-win32-arm64": "0.0.46",
+    "@supercov/cli-win32-x64": "0.0.46"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",
@@ -125,6 +125,7 @@
     "@types/node": "^24.0.0",
     "esbuild": "^0.28.2",
     "expect": "30.4.1",
+    "jest": "30.5.1",
     "next": "^16.3.2",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",

package/runtime/javascript/launchSupervisor.mjs

@@ -578,6 +578,11 @@ function injectChildEnvironment(method, args) {
     const environment = existingEnvironment
         ? { ...existingEnvironment, ...inherited }
         : { ...process.env, ...inherited };
+    // The runtime child wrapper has captured the current async test scope in
+    // these options. An inherited setup/unscoped carrier from the launcher
+    // must not overwrite it when we restore the other coverage variables.
+    if (existingEnvironment?.SUPERCOV_CONTEXT !== undefined)
+        environment.SUPERCOV_CONTEXT = existingEnvironment.SUPERCOV_CONTEXT;
     // The register path must come from THIS module's own location, never from
     // the environment or the working directory. Monorepo runners both defeat
     // the old derivation at once: turbo's strict env strips SUPERCOV_PROJECT_ROOT

package/runtime/javascript/nodeTest.mjs

@@ -87,7 +87,7 @@ function restoreUserError(error, depth = 0) {
     return error;
 }
 const registrationCounts = new Map();
-function wrappedRegistration(original, parentTestId) {
+function wrappedRegistration(original, parentTestId, forcedStatus) {
     const wrapped = function supercovNodeTest(...args) {
         const index = callbackIndex(args);
         if (index < 0)
@@ -115,13 +115,15 @@ function wrappedRegistration(original, parentTestId) {
         const scope = runnerExecutionScope(identity);
         const options = testOptions(args, index);
         const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
+        if (options?.skip || options?.todo || forcedStatus)
+            writeRunnerEvidence(identity, "skipped", scope, evidenceDirectory);
         const next = [...args];
         const execute = (callbackThis, context, done) => {
             // A test or its hooks may intentionally modify Supercov's public
             // environment while testing integrations. Keep this attempt's transport
             // destination fixed to the value present when the test was registered.
             beginBufferedServerEvidence(scope);
-            let status = options?.skip || options?.todo
+            let status = options?.skip || options?.todo || forcedStatus
                 ? "skipped"
                 : "passed";
             const contextProxy = new Proxy(context, {
@@ -138,6 +140,8 @@ function wrappedRegistration(original, parentTestId) {
                     }
                     if (property === "test" && typeof value === "function")
                         return wrappedRegistration(value.bind(target), scope.testId);
+                    if (["after", "before", "afterEach", "beforeEach"].includes(property) && typeof value === "function")
+                        return restoringHook(value.bind(target), scope);
                     return typeof value === "function" ? value.bind(target) : value;
                 },
             });
@@ -149,6 +153,11 @@ function wrappedRegistration(original, parentTestId) {
                 const flushedServerEvidence = flushBufferedServerEvidence(scope);
                 writeRunnerEvidence(identity, nextStatus, scope, evidenceDirectory, takeNodeAssertionPhases(scope), flushedServerEvidence);
             };
+            const finishBody = () => {
+                // User t.after callbacks run after the body. Register last so
+                // their assertions and cleanup probes are part of this attempt.
+                context.after(() => emit());
+            };
             try {
                 if (callback.length >= 2) {
                     const callbackDone = (error) => {
@@ -156,7 +165,7 @@ function wrappedRegistration(original, parentTestId) {
                             status = "failed";
                             restoreUserError(error);
                         }
-                        emit();
+                        finishBody();
                         done?.(error);
                     };
                     return withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, callbackThis, [contextProxy, callbackDone]));
@@ -164,19 +173,19 @@ function wrappedRegistration(original, parentTestId) {
                 const result = withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, callbackThis, [contextProxy]));
                 if (result && typeof result.then === "function")
                     return Promise.resolve(result).then((value) => {
-                        emit();
+                        finishBody();
                         return value;
                     }, (error) => {
                         status = "failed";
-                        emit();
+                        finishBody();
                         throw restoreUserError(error);
                     });
-                emit();
+                finishBody();
                 return result;
             }
             catch (error) {
                 status = "failed";
-                emit();
+                finishBody();
                 throw restoreUserError(error);
             }
         };
@@ -200,45 +209,52 @@ function wrappedRegistration(original, parentTestId) {
             Object.defineProperty(wrapped, property, {
                 configurable: true,
                 enumerable: true,
-                value: wrappedRegistration(member, parentTestId),
+                value: wrappedRegistration(member, parentTestId, property === "only" ? undefined : "skipped"),
             });
     }
     return wrapped;
 }
-// Hooks carry no coverage evidence, but an error thrown inside one still
-// reaches the report with the adapter's execution context in its stack.
-// Restore it at the same boundary the test wrapper uses.
-function restoringHook(original) {
+// Shared hooks get their own setup scope. Their execution is visible but is
+// never silently copied into every test. t.after and other per-test hooks keep
+// the exact owning attempt supplied by the TestContext proxy.
+function restoringHook(original, scope, hookName = "hook") {
     return function supercovNodeTestHook(...args) {
         const index = callbackIndex(args);
-        if (index < 0)
-            return Reflect.apply(original, this, args);
+        if (index < 0) return Reflect.apply(original, this, args);
         const callback = args[index];
+        const location = callerLocation(supercovNodeTestHook);
+        let invocation = 0;
+        const execute = (receiver, context, done) => {
+            const identity = { runner: "node:test", role: "setup", name: `[${hookName}] ${callback.name || "anonymous"}`,
+                ...location, registrationOrdinal: invocation++ };
+            const owner = scope ?? runnerExecutionScope(identity);
+            const evidenceDirectory = process.env["SUPERCOV_EVIDENCE_DIR"];
+            if (!scope) beginBufferedServerEvidence(owner);
+            let emitted = false;
+            const finish = error => {
+                if (scope || emitted) return;
+                emitted = true;
+                writeRunnerEvidence(identity, error ? "failed" : "passed", owner, evidenceDirectory,
+                    takeNodeAssertionPhases(owner), flushBufferedServerEvidence(owner));
+            };
+            try {
+                const result = withCoverageCarrier({ version: 1, scope: owner }, () =>
+                    callback.length >= 2 ? callback.call(receiver, context, error => {
+                        finish(error);
+                        done?.(error ? restoreUserError(error) : undefined);
+                    }) : callback.call(receiver, context));
+                if (callback.length >= 2) return result;
+                if (result && typeof result.then === "function")
+                    return Promise.resolve(result).then(value => { finish(); return value; },
+                        error => { finish(error); throw restoreUserError(error); });
+                finish();
+                return result;
+            } catch (error) { finish(error); throw restoreUserError(error); }
+        };
         const next = [...args];
-        // node:test uses callback arity to distinguish promise/synchronous
-        // hooks from the legacy done-callback form. Preserve it exactly.
         next[index] = callback.length >= 2
-            ? function supercovNodeTestHookDoneCallback(context, done) {
-                const restoringDone = (error) => {
-                    if (error)
-                        restoreUserError(error);
-                    done?.(error);
-                };
-                return callback.call(this, context, restoringDone);
-            }
-            : function supercovNodeTestHookCallback(context) {
-                try {
-                    const result = callback.call(this, context);
-                    if (result && typeof result.then === "function")
-                        return Promise.resolve(result).then(undefined, (error) => {
-                            throw restoreUserError(error);
-                        });
-                    return result;
-                }
-                catch (error) {
-                    throw restoreUserError(error);
-                }
-            };
+            ? function supercovNodeTestHookDoneCallback(context, done) { return execute(this, context, done); }
+            : function supercovNodeTestHookCallback(context) { return execute(this, context); };
         return Reflect.apply(original, this, next);
     };
 }
@@ -246,10 +262,10 @@ export const test = wrappedRegistration(native.test);
 export const it = wrappedRegistration(native.it);
 export const suite = native.suite;
 export const describe = native.describe;
-export const before = restoringHook(native.before);
-export const after = restoringHook(native.after);
-export const beforeEach = restoringHook(native.beforeEach);
-export const afterEach = restoringHook(native.afterEach);
+export const before = restoringHook(native.before, undefined, "before");
+export const after = restoringHook(native.after, undefined, "after");
+export const beforeEach = restoringHook(native.beforeEach, undefined, "beforeEach");
+export const afterEach = restoringHook(native.afterEach, undefined, "afterEach");
 export const mock = native.mock;
 export const snapshot = native.snapshot;
 export const run = native.run;

package/runtime/javascript/provenance.mjs

@@ -7,7 +7,10 @@ const NORMALIZED_KINDS = [
 function classifiedKind(value) {
     if (!value)
         return undefined;
-    return NORMALIZED_KINDS.find(([, pattern]) => pattern.test(value))?.[0];
+    // gatewayE2e.test.ts and responseIntegration.test.ts are conventional
+    // camel-case paths too. Do not infer kinds from test titles or API usage.
+    const words = value.replace(/([a-z0-9])([A-Z])/g, "$1-$2");
+    return NORMALIZED_KINDS.find(([, pattern]) => pattern.test(words))?.[0];
 }
 export function inferTestProvenance({ runner, file, project, explicitKind, }) {
     if (explicitKind?.trim()) {

package/runtime/javascript/register.mjs

@@ -69,17 +69,21 @@ if (verboseDiagnostics && !process.__SUPERCOV_DIAGNOSTIC_REPORTER__) {
         });
     }
 }
-// Runner adapters and instrumented modules import the runtime when they need
-// it. Keeping the preload itself thin avoids evaluating the full collector in
-// npm launchers, web-server supervisors, and other Node children that never
-// execute measured JavaScript.
-if (process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1") {
+// Direct instrumentation must initialize the collector before script files
+// with no import boundary evaluate. Other modes let the runner adapter or an
+// instrumented module load it, except when durable remote evidence requires it.
+if (process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1" ||
+    process.env.SUPERCOV_DIRECT_INSTRUMENTATION === "1") {
     // A translated remote/VM command can execute an ahead-of-run transformed
     // test through an opaque runner that bypasses the ordinary Playwright or
     // node:test import boundary. The remote-launch adapter marks that process;
     // initialize the runtime before its transformed module can evaluate.
     globalThis.__SUPERCOV_DIRECT_RUNTIME__ ??= await import("./runtime.mjs");
     process.__SUPERCOV_DIRECT_RUNTIME__ ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
+    // Generic builds can contain script files with no import/export syntax.
+    // They cannot import the collector without changing their module semantics,
+    // and may evaluate before any ESM instrumented file imports it.
+    globalThis.__supercovRuntime ??= globalThis.__SUPERCOV_DIRECT_RUNTIME__;
 }
 // Workers are independent Node processes and an explicit `execArgv: []`
 // otherwise strips the preload that supplies the isolated runtime. Preserve