supercov 0.0.44 → 0.0.45

package/docs/assertion-maps.md

@@ -0,0 +1,252 @@
+# Assertion maps
+
+Each normal test run creates `assertions.json` in its run directory. Any coding
+agent can edit that file to describe what specific assertions observe and which
+statements contribute to those observations. Rust handles syntax, references,
+input freshness, reuse and reporting. Supercov does not run an embedded model or
+reconstruct the agent's semantic reasoning with a static analyzer.
+
+## Run, investigate, save
+
+```sh
+supercov -- npm test
+supercov runs latest assertions --json
+# Pin the returned run ID; edit data.map using matching current project files.
+supercov runs <run> assertions report --view changes --json
+supercov runs <run> assertions validate --json
+# After investigating, copy expectedBasis tokens into the corresponding entries.
+supercov runs <run> assertions check --require-mappings --require-observed --json
+supercov runs <run>
+```
+
+There is no `init` or `review` command. `validate` is read-only: it returns the
+expected acknowledgements, and the agent saves them in the one editable file.
+A token says that the author acknowledges these particular inputs and this
+particular claim. It is not proof, a signature, or a model confidence score.
+
+## File format, version 2
+
+```json
+{
+  "schemaVersion": 2,
+  "assertions": [{
+    "id": "a_example",
+    "at": {
+      "file": "tests/value.test.ts", "line": 5, "column": 3,
+      "text": "assert.equal(value(), 1)"
+    },
+    "observes": ["The returned number equals one."],
+    "flows": [{
+      "id": "return-value",
+      "basis": null,
+      "appliesTo": [{ "file": "tests/value.test.ts", "name": "value" }],
+      "explanation": "The function's returned number reaches the equality assertion through value().",
+      "nodes": [{
+        "id": "return",
+        "at": { "file": "src/value.ts", "line": 2, "column": 3, "text": "return 1;" }
+      }],
+      "edges": [{ "from": "return", "to": "$assertion", "kind": "data" }],
+      "countsAsAsserted": ["return"],
+      "watch": []
+    }]
+  }]
+}
+```
+
+This is an illustrative draft; its anchors and test selector must match a real
+run before it can receive credit. `basis: null` explicitly means unacknowledged.
+`supercov assertions schema` exports the schema generated from the same Rust
+types as the parser. The published editor schema is `schemas/assertions.schema.json`.
+`supercov assertions validate --file <path> --json` checks JSON shape without a run.
+
+| Field | Meaning |
+| --- | --- |
+| `id`, `at` | Persistent assertion identity and exact assertion expression. |
+| `observes` | What the predicate distinguishes; an existence check does not check every field. |
+| `flows` | Recorded explanations. An empty array means none are recorded; there is no known total. |
+| `questions` | Optional assertion-level investigation questions. They do not establish completeness. |
+| Flow `id` | Stable within its assertion; `assertion-id/flow-id` identifies the claim. |
+| Flow `basis` | Null, or the opaque `scov2:<64 lowercase hex digits>` token supplied by validation. |
+| `appliesTo` | Explicit project-relative test file and exact displayed test name. Empty means no execution credit. |
+| `nodes`, `edges` | Exact source anchors and authored relationships ending at the reserved `$assertion` sink. |
+| `countsAsAsserted` | The node IDs judged asserted. Context nodes earn no automatic credit. |
+| `watch` | Additional whole-file dependencies as path strings. |
+| Flow `questions` | Optional unresolved questions; any entry blocks this flow's credit. |
+
+Anchors use project-relative `/` paths, one-based lines and one-based UTF-8 byte
+columns. Preserve exact text, including multiline expressions. IDs use letters,
+digits, `_`, `-`, or `.`. Edges have `from`, `to`, `kind`, and optional explanatory
+`basis` text; that edge text is distinct from the flow's acknowledgement token.
+Every counted node needs a path through the authored edges to `$assertion`.
+The checker traverses this JSON graph only; it does not infer source dependencies.
+A counted node must match one measured statement exactly to earn credit. A block
+or guard does not implicitly credit its nested body.
+
+A zero-credit explanation is useful for a fixture-only check or an absence check:
+explain the observation and use `countsAsAsserted: []`. An absent event cannot
+credit an unexecuted body. An executed guard can receive credit only when the
+author judges that the predicate observes its behavior.
+
+## Percentage and report states
+
+The regular `supercov runs <run>` report reads the map on demand. Its primary
+percentage is the union of eligible, explicitly counted measured statements,
+divided by **all measured statements** in the run. Unexecuted and unanchored
+measured statements remain in the denominator. Duplicate claims count once.
+Line credit requires all measured statements on that line to be credited.
+
+Eligibility requires valid references, current input acknowledgement, no open
+flow questions, a passing run, an exact passing assertion occurrence, and
+statement execution attributed to the same selected passing test. File + name
+selectors must resolve unambiguously. A missing or unobserved selector contributes
+nothing; an observed sibling selector can still contribute. Coexecution supports
+the agent's claim but does not establish causality or temporal ordering.
+
+| `summary.status` | Public percentage |
+| --- | --- |
+| `available` | Numeric, including a meaningful 0 when a current observed explanation credits nothing. |
+| `notAssessed` | Null: no flow explanations have been recorded. |
+| `pending` | Null: change impact remains outstanding, or no eligible current explanation exists. |
+| `unavailable` | Null or an unavailable report: failed run, invalid identities, mismatching source or unreadable map. |
+| `notApplicable` | Null: no measured statements exist. |
+
+For example:
+
+```text
+Assertions 62.50% (50/80) — agent-assessed statements, whole run
+  18 assertions with flows; 7 without; 29 current flows; 3 stale; 2 draft
+Assertions not assessed — No recorded flow explanations
+Assertions pending — Source changes need impact assessment
+```
+
+A partial map can produce a useful numeric score. Counts show assertions with
+and without flows, current/draft/stale/invalid flows, unobserved assertions,
+questions and pending changes. There is no `mapped` or `complete` status. The
+number of missing semantic flows is unknown. `current` means the claim has no
+freshness/reference/question blockers; selector evidence is reported separately.
+Diagnostic statement counts remain inspectable while change impact is pending;
+the public percentage stays null.
+
+JSON regular reports expose this under `data.assertionCoverage.summary`; detailed
+assertion reports use `data.summary`. `assertionCoverage.available` indicates
+whether the report could be read, while `summary.status` describes whether its
+percentage is available. Structural filters do not change the assertion score:
+it describes the whole run, as its label says. MC/DC remains a separate metric.
+`revision` binds each response to the map, managed state and run evidence.
+
+## Resource commands
+
+| Command | Shows |
+| --- | --- |
+| `runs <run> assertions` | Recognized and authored assertions, including sites missing from the map. |
+| `runs <run> assertions --needs-attention` | Assertions without flows, with open questions, or with flows needing investigation/evidence. |
+| `runs <run> assertion <id>` | One exact assertion and its graph, freshness, selectors and evidence. |
+| `runs <run> source <path>` | Matching current source, printed as code with line numbers. |
+| `runs <run> assertions files` | Input paths, byte sizes and SHA-256 hashes; works even with a stale checkout. |
+| `runs <run> assertions report --view <view>` | `summary`, `assertions`, `statements`, `tests`, `changes`, `creditedLines`, or `unassertedLines`. |
+| `runs <run> assertions validate --json` | Shape/reference errors, changes and flow `expectedBasis` tokens. Read-only. |
+| `runs <run> assertions check` | Read-only policy gates. |
+
+`--file <path>` filters assertion/statement/line items, never the summary.
+List views support `--offset <n> --limit <1..1000>` and `--json`. Follow
+`pagination.nextOffset`; restart a multi-page read if `revision` changes.
+Source defaults to 20 lines and prints `34 │ code here`. Source JSON uses
+`{line, text}` items for integrations. It is usable with malformed map JSON but
+requires current files matching the run. There is no separate inventory command.
+
+Large validation responses can be paged with `validate --view flows|changes|errors`
+and `--offset`/`--limit`. Entries appear under `items`; overall `valid` and
+`errorCount` still cover the whole map. Default validation returns all entries.
+
+`validate` returns exit 2 for syntax/reference errors, not merely null/stale
+acknowledgements. `check` returns exit 2 for invalid references, failed runs,
+unacknowledged/stale/invalid flows, open questions, pending impact assessments,
+or an unverifiable checkout. An incremental map with untouched empty sites is
+allowed by basic `check`. Optional gates:
+
+- `--require-mappings`: every recognized assertion observed passing has at least
+  one eligible current explanation. A zero-credit explanation qualifies. This
+  is not a claim that every flow is known.
+- `--require-observed`: every listed assertion and every explicit selector has
+  matching passing evidence. Empty selectors fail this gate.
+- `--min <0..100>`: the public statement percentage must be numeric and meet the target.
+
+## Reuse after source or test changes
+
+Run the same test command again. Before publication, Supercov selects the newest
+usable map for that exact command and language. A malformed newer candidate is
+reported under `inheritance.skipped`; fallback claims require fresh acknowledgement.
+Publication writes evidence, map and managed state together atomically. Previous
+runs stay untouched. Finish editing the newest map before starting its successor.
+
+The run stores a hash manifest and assertion identities, not complete source
+files. Current project files supply the source for investigation. Managed
+`assertions.state.json` (version 3) binds evidence and input identities and stores
+invalidation generations, outstanding change records and inheritance metadata.
+It contains no second semantic graph. Only `assertions.json` is agent-editable.
+No query changes either file.
+
+A flow depends on the assertion file, each selected test file, every node file,
+and extra `watch` files. Any byte change in those files, including comments or
+blank lines, invalidates that flow. Other sibling flows can remain current.
+Changes to the assertion/observation affect all its flows. Context/dependency/
+instrumenter changes invalidate inherited claims conservatively. Flow tokens
+bind the claim (excluding their own token), context, sorted dependency hashes,
+and effective invalidation generation; they exclude run IDs and runtime events.
+
+Exact identities retain IDs. Unique snippets or unique identical-file renames
+can relocate as suggestions. A sole unmatched old/new assertion in the same file
+can retain its ID as a changed candidate. Ambiguous/removed assertions remain
+under `retiredAssertions` with explanations. Unresolved changes stay stale across
+reruns and reverts until acknowledged. Every new run supplies fresh evidence.
+
+Every added, edited or removed file in the captured analysis scope enters the
+change queue, even if a flow already watches it. Known dependencies are a starting
+point, not proof that other flows are unaffected. Read `--view changes` and edit:
+
+```json
+{
+  "changeAssessments": [{
+    "id": "c_copy_from_changes_view",
+    "basis": null,
+    "affectedFlows": ["a_example/return-value"],
+    "explanation": "The edit affects the returned value; the independent sibling computation is unchanged."
+  }]
+}
+```
+
+This is an excerpt. Include all `knownFlows` that still exist, plus any additional
+claims affected by the change. Repair missing watches when appropriate. An empty
+list needs an explanation of why existing claims are unaffected; it does not
+mean the changed code is tested. Save responses, validate, copy examined change
+tokens, save, then validate again for final flow tokens. Impact assignment can
+invalidate another flow, so this order matters. Tokens have no circular dependency.
+Deleting a response does not clear its managed change record.
+
+On the next run, resolved changes are folded into per-flow generation baselines
+and retired. Unchanged equivalent runs preserve current tokens. Pending records
+survive and their responses must match the current input manifest. The scope is
+finite: uncaptured external state is not automatically monitored.
+
+Version-1 maps remain importable during carry; graphs and IDs are preserved,
+span watches become file watches, and all flow tokens start null. Former test
+names are retained in investigation questions until file-qualified selectors are
+provided. Missing sink edges are not invented. Legacy evidence may contain full
+source, used only to recover hashes. No migration writes into the old run.
+
+## Limits and validation
+
+The JS/TS verification matrix covers Node ESM/CommonJS/native TypeScript, Vitest
+TypeScript, Jest CommonJS and Playwright's Node-side TypeScript assertions,
+including aliases, shared parameterized sites and async rejection matchers.
+Unsupported/custom sites can be documented, but JS/TS credit requires the exact
+recognized expression and operation in runtime evidence. This does not infer
+browser assertion identity or data flows through external services.
+
+The map is an agent assessment. A credited statement can be changed without
+failing a test when the change preserves the observed property. Neither 100%
+assertion coverage nor 100% MC/DC proves mutation resistance or safety for every
+change. Use the observation and graph to select tests and identify missing
+checks; sample mutation audits can independently evaluate the authored claims.
+See [the agent workflow](assertion-agent.md), [assertion evidence](assertion-evidence.md),
+and [verification](verification.md).

package/docs/assertions.md

@@ -0,0 +1,82 @@
+# Understanding assertion coverage
+
+After a normal test run, a coding agent can map what each JavaScript or
+TypeScript assertion checks into the run's `assertions.json`. Supercov reads
+that map alongside the recorded execution evidence and displays an assertion
+percentage in the regular coverage report.
+
+```sh supercov
+npx supercov -- npm test
+npx supercov runs latest assertions --json
+```
+
+The run creates the map automatically, reusing the newest available map for the
+same test command and language. Pin the returned run ID and edit `data.map`.
+Ask your agent to follow
+`supercov docs assertion-agent`, read the current project source, and complete the map.
+Then validate and save the acknowledgement tokens for examined flows:
+
+```sh supercov-example
+npx supercov runs <run> assertions validate --json
+# Copy examined expectedBasis tokens into assertions.json; save again.
+npx supercov runs <run> assertions check --require-mappings --require-observed --json
+npx supercov runs <run>
+```
+
+The **Assertions** row appears beside Lines, Branches and MC/DC. It is the
+percentage of measured statements credited by current agent-authored flows,
+with exact passing assertion identity and execution in the same test. It uses
+the whole run with matching current source even when structural coverage is filtered. Incomplete
+maps remain useful; unmapped or dirty flows earn no credit.
+
+## Check what the test asserts
+
+Suppose `src/shipping.js` contains:
+
+```js
+export function shippingCost() {
+  return 4;
+}
+```
+
+These checks all call the function, but they test different things. Here,
+`assert` comes from `node:assert/strict`:
+
+| Assertion | What it checks |
+| --- | --- |
+| `assert.equal(shippingCost(), 4)` | The cost is exactly `4`. Returning `5` would fail. |
+| `assert.ok(shippingCost())` | The cost is truthy. Returning `5` would still pass. |
+| `shippingCost(); assert.equal(7, 7)` | Nothing about the returned cost. The assertion compares two constants. |
+
+Line coverage can be the same in all three cases. The useful test is the one
+that checks the behavior you need to preserve.
+
+The same applies to other results: checking the number of log calls does not
+check their messages, and checking one substring does not check the whole response.
+
+## Inspect and improve the map
+
+```sh supercov-example
+npx supercov runs <run> assertions --limit 5
+npx supercov runs <run> assertion <assertion-id>
+npx supercov runs <run> source src/shipping.js
+npx supercov runs <run> assertions --view statements --file src/shipping.js --limit 20
+```
+
+Each assertion keeps its exact test source anchor, the behavior it observes,
+and flows to explicit production statements. Follow those links when deciding
+whether a test needs another scenario or a stronger assertion. The model owns
+the semantic assessment; Supercov validates syntax, source references, evidence
+and freshness without reconstructing the reasoning.
+
+After changing code or tests, run the same suite command again. Its new map
+automatically carries forward unchanged entries;
+changed or ambiguous references stay dirty until reviewed. Source files are
+read from the project; each run retains file hashes and the map, without storing
+complete source copies. A stale checkout makes assertion coverage unavailable
+until tests are rerun. See the
+[map reference](assertion-maps.md) for the format, commands and limitations.
+
+MC/DC measures independent condition effects. Assertion coverage measures the
+statements linked to checks by the reviewed map. Maximizing either number does
+not prove every edit will fail a test: the exact property in `observes` matters.

package/docs/cli.md

@@ -17,7 +17,9 @@ 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` |
+| List assertions and their status | `npx supercov runs latest assertions` |
+| Inspect one assertion and its flows | `npx supercov runs latest assertion <id>` |
+| Read matching current source code | `npx supercov runs latest source <path>` |
 | Compare two runs | `npx supercov diff <older> <newer>` |
 | Combine shards | `npx supercov merge <id> <id> [...]` |
 | Remove local data | `npx supercov clean` |
@@ -72,7 +74,9 @@ 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) |
+| `assertions` | List assertions, including sites without flows, with freshness and execution status |
+| `assertion <id>` | Inspect one assertion and its authored flows |
+| `source <path>` | Read matching current project source with line numbers |
 | `minimize` | Find a small test subset that preserves a coverage target |
 
 Common examples:
@@ -93,12 +97,23 @@ 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`.
+Assertion queries read the run-owned map. `source <path>` reads the matching current
+file directly. It prints source code with line numbers, preserving indentation;
+add `--json` only when you want structured `{line, text}` items. `--offset` is
+zero-based and `--limit` controls the number of source lines. Source and assertion analysis require the current
+checkout to match the run. Changed source makes assertion coverage unavailable;
+rerun tests to inherit mappings. The old `assertions inventory` and nested
+`assertions source --file` commands are replaced by these resource queries.
+Use read-only `assertions validate --json` to obtain expected acknowledgement tokens.
+After investigating, copy those tokens into `assertions.json`, save, and run
+`assertions check`. The `review` command is removed. `--require-mappings` requires
+a current explanation per recognized passing site, without implying completeness.
+Use `assertions --needs-attention` and `assertions report --view changes` to resume work.
+The regular run summary automatically includes the assertion percentage when
+that map exists, in text and `data.assertionCoverage` JSON. Read
+[Understanding assertion coverage](assertions.md) for the workflow or run
+`npx supercov docs assertion-agent` for instructions to give a coding agent.
+The [map reference](assertion-maps.md) covers syntax and verification gates.
 
 ## Narrow a view
 

package/docs/coverage-model.md

@@ -71,6 +71,9 @@ does not mean the product has no bugs, the assertions are meaningful, or every
 possible input was tested. Review test quality and user-visible behavior, not
 only the percentage.
 
+To review what your JavaScript and TypeScript tests actually check, see
+[Understanding assertions](assertions.md).
+
 If source cannot be measured safely, Supercov reports a measurement limit
 instead of claiming completeness.
 
@@ -138,3 +141,12 @@ the bundler consumes them at build time; nothing about them runs.
 
 Choose roots that describe code the repository owns. Do not include dependencies
 or generated output merely to make a warning disappear.
+
+## Assertion percentage
+
+When a run has an `assertions.json` map, its regular summary also shows
+agent-assessed assertion coverage: credited measured statements divided by all
+measured statements. This row always describes the whole archived run,
+independently of `--filter`, `--kind` and `--runner`. It is separate from the
+structural metrics above. See [assertion maps](assertion-maps.md) for credit,
+freshness and incomplete-map rules.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "supercov",
-  "version": "0.0.44",
-  "description": "Coverage for coding agents and software factories 🌙",
+  "version": "0.0.45",
+  "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,31 @@
     "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",
+    "test:assertion-maps:js": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-js-integration.mjs",
+    "sync:assertion-schema": "cargo build -p supercov && node scripts/assertion-map-schema.mjs"
   },
   "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.45",
+    "@supercov/cli-darwin-x64": "0.0.45",
+    "@supercov/cli-linux-arm64-gnu": "0.0.45",
+    "@supercov/cli-linux-arm64-musl": "0.0.45",
+    "@supercov/cli-linux-x64-gnu": "0.0.45",
+    "@supercov/cli-linux-x64-musl": "0.0.45",
+    "@supercov/cli-win32-arm64": "0.0.45",
+    "@supercov/cli-win32-x64": "0.0.45"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",
@@ -125,6 +123,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",