supercov 0.0.41 → 0.0.43

package/docs/assertion-evidence.md

@@ -0,0 +1,135 @@
+# Assertion evidence (JS/TS)
+
+Supercov can analyze which source behaviors existing assertions appear to check,
+using an ordinary run archive, its matching source, and the existing statement
+and assertion-phase evidence. This work happens after tests. It adds no new
+test-time probes, does not run mutants, and does not rewrite your tests.
+
+This is candidate evidence, not a proof that arbitrary changes are safe.
+`assertionScore` remains null. Execution-only links, test gaps and analysis limits
+are different things; do not interpret a passing assertion nearby as protection.
+
+## Requirements
+
+Use the **npm Supercov launcher**, which supplies the installed analyzer assets.
+The current JS/TS adapter is exercised with Node's test runner and Vitest.
+Browser, background, merged, retried and ambiguously attributed records have
+explicit limitations; other language assertion analyzers are not enabled here.
+
+The analyzed project must provide a TypeScript compiler API, **even for a
+JavaScript project**. For example, add TypeScript as a development dependency
+before recording the run. The analyzer uses that project's compiler, not a
+silently substituted global or bundled version. Installing it afterward changes
+the dependency fingerprint, so rerun the suite. Missing/incompatible compiler APIs
+produce an error. **TypeScript 5.8.3 and native 7.0.2 are tested.** Version 7.0.2
+uses its own native parser/checker, not a fallback to TypeScript 5. Install its
+platform-specific optional dependency too; the report hashes both the JS client
+and the native compiler package, including its standard libraries. This backend
+requires Node 22.12 or newer (Node 24 tested), and uses original-source evidence
+from ordinary Supercov archives, not legacy ts-node/V8 generated-line coverage.
+Native module resolution currently follows actual import/export references;
+unresolved helper-only specifiers remain visible as compiler limitations.
+Other native compiler versions are not enabled until separately calibrated.
+Do not downgrade an application's compiler just to improve an assertion report.
+
+Compiler compatibility and regression checks do not prove general correctness.
+All candidates remain unverified and `assertionScore` remains null. Query-side
+native compiler work adds no test-time instrumentation.
+
+Standalone native/Python/Ruby distributions do not currently bundle this JS/TS
+analyzer. Use the npm launcher, or explicitly set `SUPERCOV_PACKAGE_ROOT` to an
+installed npm package directory. Normal coverage commands are unaffected.
+
+## Run, inspect, follow evidence
+
+`assertions` analyzes source behaviors and their assertion evidence; it does not
+just count or list assertion calls. Use `npx supercov docs assertion-evidence`
+to read this guide from the installed package.
+
+```sh
+npx supercov -- npm test
+npx supercov runs latest assertions --limit 5
+npx supercov runs latest assertions --file src/core.ts --json
+npx supercov runs latest assertions --site '<site-id>' --json
+```
+
+The summary reports candidate counts and the site denominator, without claiming
+a verified assertion percentage. Each ordinary site row contains its source,
+candidate classification, available facts, and an `evidence.pointer` for full
+details. Global tests, attempts, execution links, diagnostics and source-scope
+limits are referenced under `evidence`, not repeated inside every site page.
+
+```sh
+npx supercov runs latest assertions --evidence /tests --limit 5 --json
+npx supercov runs latest assertions --evidence /diagnostics --json
+npx supercov runs latest assertions --evidence /sites/0/facts --json
+```
+
+Pointers use JSON Pointer syntax: escape `/` in a property name as `~1` and `~`
+as `~0`. Use an empty pointer (`--evidence ''`) for the document root. Follow
+returned pointers rather than constructing indices from filtered page offsets:
+site pointers index the complete, stable inventory.
+
+## Pagination and oversized records
+
+All JSON responses stay within the normal response budget. Pages may contain
+fewer than `--limit` results: **follow `pagination.nextOffset`**, not offset plus
+the requested limit. `hasMore: false` marks the end.
+
+An oversized site/hint is returned as `detailOnly: true` with an
+`evidence.pointer`. Nothing has been discarded. An evidence page returns immediate
+object members or array entries as `items`. Small entries contain `value`; large
+ones contain `detailOnly: true` and another `pointer` to inspect. String leaves
+return `text` chunks, with offsets/counts measured in Unicode scalar values,
+not bytes. This allows reading one large observation or diagnostic completely.
+
+```sh
+npx supercov runs '<run-id>' assertions --evidence '<returned-pointer>' \
+  --offset 0 --limit 4000 --analysis '<analysisId>' --json
+```
+
+Every page carries an `analysisId` hashing the complete derived document and its
+provenance. Pass the first page's id as `--analysis` on follow-ups to reject mixed
+analyses if the compiler, analyzer, or derived results change. Use a fixed run id
+instead of `latest` while paging. Source/run freshness checks still run on every
+query. Derived results are not cached or written into the archive.
+
+JSON reports use `reportSchema: 2`. Shared evidence is accessed through the
+evidence pointers above.
+Success and error JSON envelopes identify this query as `coverage.assertions`.
+
+## Optional assertion hints
+
+```ts
+// observes: src/core.ts#compute return value
+assert.equal(compute(), 4);
+```
+
+The comment must precede a statement containing exactly one recognized assertion.
+The project-relative file, exact function/owner name, and optional literal source
+substring must select one inventory site. Optional `via ...` is explanation only.
+
+```sh
+npx supercov runs latest assertions --pragmas --json
+```
+
+Origin is `user-suggested`; validation is separately `analyzer-supported`,
+`unresolved`, or `invalid`. Support requires the named assertion's exact passing
+witness and a connection supported by the ordinary effect rules. Strength remains
+presence/value/total; presence does not mean value protection. Unsupported
+decision, absence and internal-state paths remain unresolved. A missing inventory
+match may reflect unsupported source rather than a bad declaration.
+
+Hints cannot inject observations, borrow another assertion's evidence, inflate
+coverage or remove sites from the denominator. Editing comments changes test
+source and requires a new run. Supported hints retain the analyzer's limitations;
+they are not formal proofs.
+
+## Agent workflow
+
+Read coverage first, then inspect assertion candidates and their evidence before
+writing another test. An execution gap may need a reachable scenario; an assertion
+gap may need a stronger check. An analysis limit needs investigation—not a test
+written just to satisfy the analyzer. Keep the original denominator and unresolved
+work visible. Never automatically treat an `evident` candidate as permission to
+change application behavior.

package/docs/cli.md

@@ -17,6 +17,7 @@ npx supercov --help
 | Read the newest run | `npx supercov runs latest` |
 | Find useful gaps | `npx supercov runs latest gaps` |
 | Inspect one file | `npx supercov runs latest file <path>` |
+| Inspect assertion evidence (JS/TS) | `npx supercov runs latest assertions` |
 | Compare two runs | `npx supercov diff <older> <newer>` |
 | Combine shards | `npx supercov merge <id> <id> [...]` |
 | Remove local data | `npx supercov clean` |
@@ -71,6 +72,7 @@ npx supercov runs <run-id> [query] [options]
 | `kinds` | Group coverage by test level, such as unit or E2E |
 | `runners` | Group coverage by test runner |
 | `scope` | Review included, excluded, and ambiguous source files |
+| `assertions` | Analyze source-to-assertion evidence, gaps, and limits (JS/TS) |
 | `minimize` | Find a small test subset that preserves a coverage target |
 
 Common examples:
@@ -88,8 +90,16 @@ Run any query with `--help` to see only the options valid for that query:
 ```sh
 npx supercov runs latest --help
 npx supercov runs latest file --help
+npx supercov runs latest assertions --help
 ```
 
+The npm-only `assertions` query runs after tests against matching source. It
+reports unverified candidates, not a proven assertion score or permission to
+change behavior. Its filters differ from the structural queries below; see
+[assertion evidence](assertion-evidence.md) for requirements, pagination, and
+optional assertion hints. The guide is also available through
+`npx supercov docs assertion-evidence`.
+
 ## Narrow a view
 
 | Option | Meaning |

package/docs/code-verification.md

@@ -0,0 +1,182 @@
+# Example
+
+This example measures coverage for a small checkout function. It includes the
+original tests, an additional test for an expired session, and commands for
+comparing the results.
+
+## Before you start
+
+You need Node.js 22 or newer and npm. Clone the repository and install the
+example's dependencies:
+
+```sh
+git clone --depth 1 https://github.com/supercorp-ai/supercov.git
+cd supercov/examples/checkout-verification
+npm ci
+```
+
+Run the commands below from this directory. The example uses Supercov 0.0.42
+and Node's built-in test runner. Both the original tests and the additional
+test are included. The first three steps do not require any file edits.
+
+## 1. Run the original tests
+
+In `src/session.js`, checkout is allowed only if the customer is signed in and
+their session has not expired:
+
+```js
+export function canCheckout(signedIn, expired) {
+  if (signedIn && !expired) return true;
+  return false;
+}
+```
+
+The two tests in `tests/session.test.js` check a valid session and a signed-out
+visitor:
+
+```js
+assert.equal(canCheckout(true, false), true);
+assert.equal(canCheckout(false, false), false);
+```
+
+Run those tests through Supercov, then open the summary:
+
+```sh
+npx supercov -- node --test tests/session.test.js
+npx supercov runs latest
+```
+
+Everything after `--` is the test command Supercov runs. In your own project,
+use your existing test command there.
+
+Both tests pass. The coverage section shows:
+
+```text
+Coverage
+  Lines      100.00% (3/3)
+  Branches   100.00% (2/2)
+  MC/DC      50.00% (1/2)
+```
+
+Line and branch coverage are 100% because the tests reach both `return true`
+and `return false`. The MC/DC result shows there is still a condition to test.
+
+Keep the run ID printed at the top of the summary. You'll use it to compare
+this run with the next one.
+
+## 2. Inspect the missing condition
+
+Ask about the decision on line 2:
+
+```sh
+npx supercov runs latest decision src/session.js:2
+```
+
+```text
+signedIn && !expired
+C1 covered + asserted: signedIn
+C2 MISSING: !expired
+confidence asserted; asserted MC/DC 1/2
+```
+
+MC/DC stands for Modified Condition/Decision Coverage. It checks whether each
+condition has independently affected the decision. The original tests show
+that changing `signedIn` changes the result, but neither test changes `expired`.
+That leaves one of two conditions covered: 50%.
+
+`C2 MISSING: !expired` points to the case to test: a customer who is still
+signed in, but whose session has expired. Checkout should be denied.
+
+## 3. Include the expired-session test
+
+`tests/expired-session.test.js` contains that test:
+
+```js
+test('an expired session cannot check out', () => {
+  assert.equal(canCheckout(true, true), false);
+});
+```
+
+Run both test files and open the new summary:
+
+```sh
+npx supercov -- node --test tests/session.test.js tests/expired-session.test.js
+npx supercov runs latest
+```
+
+All three tests pass:
+
+```text
+Coverage
+  Lines      100.00% (3/3)
+  Branches   100.00% (2/2)
+  MC/DC      100.00% (2/2)
+```
+
+Query the same decision again:
+
+```sh
+npx supercov runs latest decision src/session.js:2
+```
+
+The expiry condition is now covered. `asserted MC/DC 2/2` means both conditions
+have coverage evidence linked to passing assertions:
+
+```text
+C2 covered + asserted: !expired
+confidence asserted; asserted MC/DC 2/2
+```
+
+Compare the runs, replacing `<before-run-id>` with the ID you saved in step 1:
+
+```sh
+npx supercov diff <before-run-id> latest
+```
+
+```text
+lines +0pp, branches +0pp, MC/DC +50pp
+gained: 0 lines, 0 branches, 1 MC/DC conditions
+lost: 0 lines, 0 branches, 0 MC/DC conditions
++ MC/DC src/session.js:2 C2 !expired
+```
+
+Line and branch coverage have not changed. The new test covers the missing
+expiry condition without changing application code.
+
+## 4. Check that the test catches a regression
+
+In this example only, temporarily remove the expiry check from `src/session.js`:
+
+```diff
+-  if (signedIn && !expired) return true;
++  if (signedIn) return true;
+```
+
+Run the original two tests against the changed function:
+
+```sh
+npx supercov -- node --test tests/session.test.js
+```
+
+Then include the expired-session test:
+
+```sh
+npx supercov -- node --test tests/session.test.js tests/expired-session.test.js
+```
+
+| Tests run against the changed function | Result |
+| --- | --- |
+| Original two tests | Both pass. |
+| All three tests | The expired-session test fails; the other two pass. |
+
+The new test expects `false`, but the changed function returns `true`. The
+second command should fail: that is the test catching the removed expiry check.
+
+Restore `&& !expired` in `src/session.js` when you finish, then rerun all three
+tests with the same command. They should pass again.
+
+## Next
+
+- [Full example and recorded output](https://github.com/supercorp-ai/supercov/tree/main/examples/checkout-verification) — source, tests, and the complete output excerpted above.
+- [Understanding coverage](coverage-model.md) — what each metric measures and what 100% means.
+- [Agent workflow](agent-loop.md) — use the same run, inspect, test, and compare steps with a coding agent.

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 concurrent and parameterized tests |
+| 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 |
 | `node:test` | Exact per test |
 | AVA and Mocha | Aggregate structural coverage |
 | Other Node-based runners | Aggregate when their processes remain visible to Supercov |
@@ -109,7 +109,7 @@ whatever was still buffered.
 
 | Runner | Attribution | Current requirement |
 | --- | --- | --- |
-| Cargo's standard libtest runner | Exact test and attempt identity | Rust 1.95; run with `npx supercov -- cargo test` |
+| Cargo's standard libtest runner | Exact test, attempt, and passing-assertion identity | Rust 1.95; run with `npx supercov -- cargo test` |
 | rustdoc doctests | Exact doctest identity; every doctest runs in a process of its own | Rust 1.95; part of `npx supercov -- cargo test` |
 | cargo-nextest | Exact test, attempt, retry, and binary identity | cargo-nextest 0.9.138 or 0.9.140 |
 
@@ -125,7 +125,9 @@ 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; const contexts and macro expansions stay in 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:
 
@@ -147,10 +149,19 @@ 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`, and a few
+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`.
@@ -186,6 +197,12 @@ 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
@@ -208,20 +225,36 @@ 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. A Spring
+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-position-sweep.rb`) over Ruby's whole standard library and the
-Rails, Rack, RSpec, Minitest and Cucumber gems, about 3,000 files: every file
-is transformed and compiled, and every position Supercov expects is compared
-with what Ruby reports. With `--load` each file also runs twice, untouched and
-transformed, so the probes are proven to preserve behaviour and every method
-position is checked.
+(`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

package/docs/troubleshooting.md

@@ -176,3 +176,16 @@ never looks complete. Since 0.0.29 the background and execution-trace writers al
 clone sharing their file and move to a fresh one, so this should be rare; if it
 persists, check whether something outside Supercov appends to
 `.supercov/…/server/background/`.
+
+## "Complete ... — N declared boundary(ies)"
+
+A limitation is either blocking or declared. A blocking one means Supercov
+could not measure something inside the denominator it claims — corrupt
+evidence, a transport that never reported — and the run reads as
+"Incomplete". A declared one marks a boundary of the denominator itself: a
+Rust macro the compiler expands, a `const fn` body no runtime probe can
+enter, a proc-macro crate whose code runs inside the compiler. Nothing inside
+the measured denominator went unmeasured, so the run reads as complete within
+those boundaries, and each boundary is reported at the line it covers with a
+reason. `runs <run> file <path>` lists them per file; the `measurement`
+object in `--json` output counts them under `declared`.

package/docs/verification.md

@@ -78,6 +78,18 @@ self-consistent calculation error does not pass unnoticed. Python and Ruby
 gates run real suites through their supported runners and assert the resulting
 coverage totals, test identity, and measurement limits.
 
+Rust numbers are also checked against an independent LLVM line-coverage
+oracle over real crates. `npm run oracle:rust` runs the same tests plain, under
+the oracle, and under Supercov on twenty-six crates from bytes to tokio,
+compares line coverage file by file, and fails if Supercov ran any suite
+differently from plain Cargo. The two tools count differently — the oracle
+counts every executable region after monomorphisation, Supercov the lines its
+own obligations sit on — so the per-file comparison is read by a person: a file
+at 0% in one and 70% in the other means lost evidence or a wrong denominator,
+and this check found five such defects before 0.0.42. It runs locally and
+costs no hosted minutes; `scripts/rust-coverage-oracle.mjs` documents what
+each flag means.
+
 These checks reduce risk; they do not replace reviewing the assertions and
 behavior protected by a new test.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "supercov",
-  "version": "0.0.41",
-  "description": "Zero-edit, runner-aware coverage completeness for JavaScript, TypeScript, Rust, Python, and Ruby test suites",
+  "version": "0.0.43",
+  "description": "Coverage for coding agents and software factories 🌙",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,6 +16,19 @@
     "bin",
     "runtime/javascript",
     "docs",
+    "analyzers/typescript/bin",
+    "analyzers/typescript/dist/analyze.js",
+    "analyzers/typescript/dist/archive.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",
     "README.md"
   ],
   "engines": {
@@ -34,6 +47,7 @@
   },
   "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)",
@@ -41,16 +55,19 @@
     "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 && node scripts/packed-npx-integration.mjs",
+    "test:packed-npx": "cargo build --release -p supercov && npm run build:asserted-typescript && 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",
     "test:engine-contract": "cargo build -p supercov && node scripts/engine-contract.mjs",
     "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-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: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 && node scripts/native-package-integration.mjs && node scripts/native-release-set-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: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",
@@ -61,11 +78,12 @@
     "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 && 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:asserted-typescript && npm run test:asserted-integration && npm run test:asserted-package && 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",
-    "prepack": "node scripts/package-preflight.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",
     "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",
@@ -74,14 +92,14 @@
     "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "0.0.41",
-    "@supercov/cli-darwin-x64": "0.0.41",
-    "@supercov/cli-linux-arm64-gnu": "0.0.41",
-    "@supercov/cli-linux-arm64-musl": "0.0.41",
-    "@supercov/cli-linux-x64-gnu": "0.0.41",
-    "@supercov/cli-linux-x64-musl": "0.0.41",
-    "@supercov/cli-win32-arm64": "0.0.41",
-    "@supercov/cli-win32-x64": "0.0.41"
+    "@supercov/cli-darwin-arm64": "0.0.43",
+    "@supercov/cli-darwin-x64": "0.0.43",
+    "@supercov/cli-linux-arm64-gnu": "0.0.43",
+    "@supercov/cli-linux-arm64-musl": "0.0.43",
+    "@supercov/cli-linux-x64-gnu": "0.0.43",
+    "@supercov/cli-linux-x64-musl": "0.0.43",
+    "@supercov/cli-win32-arm64": "0.0.43",
+    "@supercov/cli-win32-x64": "0.0.43"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",