diff --git a/.github/workflows/pr-checks.yml b/.github/workflows/pr-checks.yml
index 8286609..60a133a 100644
--- a/.github/workflows/pr-checks.yml
+++ b/.github/workflows/pr-checks.yml
@@ -1,21 +1,37 @@
 name: PR checks
 
-# Per-package parallel pipeline: each codec is built, tested, and benchmarked
-# independently. The matrix mirrors what CircleCI was doing — every entry
-# runs concurrently, any failure fails the workflow.
+# Pipeline: builds run as a per-package parallel matrix (wasm compiles are
+# the slow part), then a single test job runs the whole vitest workspace
+# against the built dists, and CodSpeed benches the packages the PR touched.
+#
+# Toolchain bumps (emsdk image tag below, root package.json/yarn.lock, this
+# workflow itself) force the FULL pipeline including a full bench sweep.
+# Expect such a PR to also need:
+#   1. tools/dist-size/baseline.json regenerated from that PR's own CI
+#      artifacts: gh run download <run-id> --pattern 'dist-*' -d tmp/ then
+#      node tools/dist-size/check.js --update --artifacts tmp/ (commit diff)
+#   2. possibly regenerated lossy decode goldens (openjpeg .91, charls .81,
+#      openjphjs corpus SHAs) IF the lossless tests still pass — see
+#      tools/fixture-verification/README.md before touching any golden.
 #
 # CodSpeed's first-class GHA integration replaces the manual codspeed-bench
-# job from CircleCI: `CodSpeedHQ/action@v3` installs valgrind, sets up
+# job from CircleCI: `CodSpeedHQ/action` installs valgrind, sets up
 # instrumentation, and uploads results in one step.
 
 on:
   pull_request:
   push:
-    # Run on every branch including main so each merge to main seeds a
-    # fresh CodSpeed baseline. Without a main run, PR comments stay stuck
-    # on "Congrats! CodSpeed is installed" with no before/after deltas.
+    # Run pushes on main only: each merge seeds a fresh CodSpeed baseline
+    # (without a main run, PR comments stay stuck on "Congrats! CodSpeed
+    # is installed" with no before/after deltas). PR branches are already
+    # covered by the pull_request event — running push on them too meant
+    # every commit was built/tested/benched TWICE and uploaded two
+    # CodSpeed measurements per commit, each on a randomly allocated
+    # runner CPU (GitHub mixes Intel 8370C and AMD EPYC 7763 hardware),
+    # which is a prime source of "Different runtime environments detected"
+    # warnings on comparisons.
     branches:
-      - "**"
+      - main
   # workflow_dispatch lets CodSpeed trigger a backtest run from the
   # dashboard (to seed initial perf data after the repo is connected).
   workflow_dispatch:
@@ -32,13 +48,20 @@ permissions:
 
 jobs:
   detect-changes:
-    # Build the matrix dynamically from the set of packages that actually
-    # changed since main. Mirrors CircleCI's --since main skip logic. On a
-    # PR where every README was touched (this branch) the list is the full
-    # 8 packages; on a docs-only PR the build matrix is empty.
+    # Decide what this run needs to do. Two outputs:
+    #   packages — what to build (and therefore what the test job can rely
+    #     on). dicom-codec's integration tests decode through EVERY sibling
+    #     codec's dist, and the in-test CI guards fail loudly when a dist is
+    #     missing (no more silently-skipped suites), so any package change
+    #     builds the full set. Docs-only changes still skip everything.
+    #   bench — only the packages that actually changed. CodSpeed benches
+    #     run under valgrind (the slowest job in the workflow), and a PR
+    #     only needs deltas for what it touched; main re-benches everything
+    #     to keep full baselines.
     runs-on: ubuntu-latest
     outputs:
       packages: ${{ steps.list.outputs.packages }}
+      bench: ${{ steps.list.outputs.bench }}
       any: ${{ steps.list.outputs.any }}
     steps:
       - uses: actions/checkout@v4
@@ -52,6 +75,7 @@ jobs:
         run: |
           set -e
           ALL=(charls libjpeg-turbo-8bit libjpeg-turbo-12bit openjpeg openjphjs little-endian big-endian dicom-codec)
+          ALL_JSON=$(printf '%s\n' "${ALL[@]}" | jq -R . | jq -s -c .)
 
           # Baseline runs: on a manual dispatch or any commit landing on
           # main, build/test/bench every package. The "diff vs main" trick
@@ -59,15 +83,46 @@ jobs:
           # `git diff origin/main..HEAD` is empty and would skip CodSpeed
           # entirely, leaving the dashboard with no baseline data.
           if [ "$EVENT_NAME" = "workflow_dispatch" ] || [ "$REF" = "refs/heads/main" ]; then
-            json=$(printf '%s\n' "${ALL[@]}" | jq -R . | jq -s -c .)
             echo "Baseline run ($EVENT_NAME on $REF): forcing all packages"
-            echo "packages=$json" >> "$GITHUB_OUTPUT"
+            echo "packages=$ALL_JSON" >> "$GITHUB_OUTPUT"
+            echo "bench=$ALL_JSON" >> "$GITHUB_OUTPUT"
             echo "any=true" >> "$GITHUB_OUTPUT"
             exit 0
           fi
 
           git fetch --no-tags --depth=50 origin main || true
           BASE=$(git merge-base origin/main HEAD || echo "origin/main")
+
+          # Toolchain files affect how EVERY package is built, tested or
+          # measured. A change here (e.g. an emsdk bump in this workflow, or
+          # a vitest upgrade in the root lockfile) must run the full
+          # pipeline with a full bench sweep — previously such PRs matched
+          # no package path and skipped CI entirely. tools/ entries count
+          # too: browser-smoke drives the browser-smoke job, and the test
+          # suites import reference derivations from
+          # tools/fixture-verification/gen/ — a change to either must not
+          # land with CI skipped.
+          TOOLCHAIN_PATHS=(
+            ".github/workflows/"
+            "package.json"
+            "yarn.lock"
+            "vitest.workspace.mjs"
+            "babel.config.json"
+            "lerna.json"
+            "tools/dist-size/"
+            "tools/browser-smoke/"
+            "tools/fixture-verification/"
+          )
+          for p in "${TOOLCHAIN_PATHS[@]}"; do
+            if ! git diff --quiet "$BASE"..HEAD -- "$p"; then
+              echo "Toolchain change detected in $p: forcing all packages (build/test/bench)"
+              echo "packages=$ALL_JSON" >> "$GITHUB_OUTPUT"
+              echo "bench=$ALL_JSON" >> "$GITHUB_OUTPUT"
+              echo "any=true" >> "$GITHUB_OUTPUT"
+              exit 0
+            fi
+          done
+
           changed=()
           for pkg in "${ALL[@]}"; do
             if ! git diff --quiet "$BASE"..HEAD -- "packages/$pkg/"; then
@@ -77,11 +132,13 @@ jobs:
           if [ ${#changed[@]} -eq 0 ]; then
             echo "No packages changed since $BASE."
             echo 'packages=[]' >> "$GITHUB_OUTPUT"
+            echo 'bench=[]' >> "$GITHUB_OUTPUT"
             echo "any=false" >> "$GITHUB_OUTPUT"
           else
-            json=$(printf '%s\n' "${changed[@]}" | jq -R . | jq -s -c .)
-            echo "Changed packages: $json"
-            echo "packages=$json" >> "$GITHUB_OUTPUT"
+            bench_json=$(printf '%s\n' "${changed[@]}" | jq -R . | jq -s -c .)
+            echo "Changed: $bench_json — building all packages, benching changed only"
+            echo "packages=$ALL_JSON" >> "$GITHUB_OUTPUT"
+            echo "bench=$bench_json" >> "$GITHUB_OUTPUT"
             echo "any=true" >> "$GITHUB_OUTPUT"
           fi
 
@@ -107,8 +164,15 @@ jobs:
           apt-get clean -y
           rm -rf /var/lib/apt/lists/*
       - uses: actions/checkout@v4
+        # Shallow checkout: builds only need the working tree (full history
+        # is only required by detect-changes for the merge-base diff).
+      - uses: actions/setup-node@v4
+        # The emsdk image bundles node 20.18.0, which fails vite 7's engine
+        # check (needs >=20.19) during yarn install. Put node 22 on PATH for
+        # yarn/webpack; emscripten is unaffected — emcc invokes the node
+        # binary pinned in its own .emscripten config, not the one on PATH.
         with:
-          fetch-depth: 0
+          node-version: '22'
       - name: Allow git to operate on the workspace
         # The container runs as root but the workspace is owned by the
         # checkout action's user, which makes git complain about
@@ -121,13 +185,16 @@ jobs:
           else
             echo "No extern/ submodule for ${{ matrix.package }}; skipping."
           fi
-      - name: Restore yarn cache
+      - name: Restore node_modules cache
+        id: modules-cache
         uses: actions/cache@v4
         with:
-          path: ~/.cache/yarn
-          key: yarn-${{ hashFiles('yarn.lock') }}
-          restore-keys: yarn-
+          path: |
+            node_modules
+            packages/*/node_modules
+          key: modules-build-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('yarn.lock') }}
       - name: Install dependencies
+        if: steps.modules-cache.outputs.cache-hit != 'true'
         run: yarn install --frozen-lockfile
       - name: Build
         run: cd "packages/${{ matrix.package }}" && yarn run build:ci
@@ -142,12 +209,13 @@ jobs:
           retention-days: 7
 
   test:
+    # One job for the whole vitest workspace: per-package test jobs spent far
+    # more on runner setup (checkout, node, artifact download, yarn install)
+    # than on the few seconds of vitest itself, and dicom-codec's suite needs
+    # every sibling dist anyway. CI=true (set by GitHub) arms the in-test
+    # guards: a missing dist FAILS its suite instead of silently skipping.
     needs: [detect-changes, build]
     if: needs.detect-changes.outputs.any == 'true'
-    strategy:
-      fail-fast: false
-      matrix:
-        package: ${{ fromJson(needs.detect-changes.outputs.packages) }}
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -173,20 +241,50 @@ jobs:
             cp -r "$d"/* "packages/$pkg/dist/" 2>/dev/null || true
           done
           ls packages/*/dist 2>/dev/null | head
-      - name: Restore yarn cache
+      - name: Restore node_modules cache
+        id: modules-cache
         uses: actions/cache@v4
         with:
-          path: ~/.cache/yarn
-          key: yarn-${{ hashFiles('yarn.lock') }}
-          restore-keys: yarn-
+          path: |
+            node_modules
+            packages/*/node_modules
+          key: modules-node22-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('yarn.lock') }}
       - name: Install dependencies
+        if: steps.modules-cache.outputs.cache-hit != 'true'
         run: yarn install --frozen-lockfile
       - name: Test
-        run: cd "packages/${{ matrix.package }}" && yarn run test:ci
+        run: npx vitest run
 
-  codspeed-bench:
+  dist-size:
+    # Binary-size regression gate: compares every shipped dist artifact
+    # (js/wasm/mem, raw and gzip) against the ground truth committed in
+    # tools/dist-size/baseline.json and fails if anything grows beyond
+    # max(1%, 1 KiB). Intentional size changes update the baseline in the
+    # same PR (node tools/dist-size/check.js --update) so growth is always
+    # a visible, reviewed diff.
+    needs: [detect-changes, build]
+    if: needs.detect-changes.outputs.any == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download all built dists
+        uses: actions/download-artifact@v4
+        with:
+          pattern: dist-*
+          path: tmp/
+      - name: Check dist sizes against baseline
+        run: node tools/dist-size/check.js --artifacts tmp
+
+  browser-smoke:
+    # Decodes every build variant in headless Chromium and hash-compares
+    # against the RAW references — catches emscripten glue regressions that
+    # only manifest in browsers (wasm URL resolution, MIME/streaming
+    # compile, fetch loading), which is where emsdk bumps break first.
+    # Advisory while it beds in; promote to blocking once proven stable.
     needs: [detect-changes, build]
     if: needs.detect-changes.outputs.any == 'true'
+    continue-on-error: true
+    timeout-minutes: 15
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -208,14 +306,96 @@ jobs:
             shopt -s dotglob nullglob
             cp -r "$d"/* "packages/$pkg/dist/" 2>/dev/null || true
           done
-      - name: Restore yarn cache
+      - name: Restore node_modules cache
+        id: modules-cache
         uses: actions/cache@v4
         with:
-          path: ~/.cache/yarn
-          key: yarn-${{ hashFiles('yarn.lock') }}
-          restore-keys: yarn-
+          path: |
+            node_modules
+            packages/*/node_modules
+          key: modules-node22-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('yarn.lock') }}
       - name: Install dependencies
+        if: steps.modules-cache.outputs.cache-hit != 'true'
         run: yarn install --frozen-lockfile
+      - name: Cache Playwright chromium
+        id: pw-cache
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/ms-playwright
+          key: playwright-chromium-${{ runner.os }}-${{ hashFiles('yarn.lock') }}
+      - name: Install chromium
+        if: steps.pw-cache.outputs.cache-hit != 'true'
+        run: npx playwright-core install chromium
+      - name: Browser smoke decode
+        run: node tools/browser-smoke/run.js
+
+  codspeed-bench:
+    needs: [detect-changes, build]
+    if: needs.detect-changes.outputs.any == 'true'
+    # Pin the OS (not ubuntu-latest) so PR runs are measured in the same
+    # runtime environment as the baseline seeded on main. A drifting
+    # ubuntu-latest image changes the valgrind/toolchain fingerprint between
+    # baseline and PR, which makes CodSpeed report "Different runtime
+    # environments detected" and refuse to trust the comparison. The baseline
+    # on main must be re-seeded after changing this so both sides match.
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - name: Download all built dists
+        uses: actions/download-artifact@v4
+        with:
+          pattern: dist-*
+          path: tmp/
+      - name: Replay dists into packages/<pkg>/dist
+        run: |
+          set -e
+          for d in tmp/dist-*; do
+            [ -d "$d" ] || continue
+            pkg=$(basename "$d" | sed 's/^dist-//')
+            mkdir -p "packages/$pkg/dist"
+            shopt -s dotglob nullglob
+            cp -r "$d"/* "packages/$pkg/dist/" 2>/dev/null || true
+          done
+      - name: Restore node_modules cache
+        id: modules-cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            packages/*/node_modules
+          key: modules-node22-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('yarn.lock') }}
+      - name: Install dependencies
+        if: steps.modules-cache.outputs.cache-hit != 'true'
+        run: yarn install --frozen-lockfile
+      - name: Log CPU info
+        # GitHub standard runners are randomly assigned different physical
+        # CPUs (e.g. Intel Xeon 8370C vs AMD EPYC 7763) with different cache
+        # sizes and ISA extensions; glibc dispatches different code paths on
+        # each, so even simulation-mode instruction counts shift between
+        # them. CodSpeed flags such comparisons as "different runtime
+        # environments". Logging the CPU makes those warnings diagnosable
+        # at a glance (recommendation from
+        # https://codspeed.io/blog/unrelated-benchmark-regression).
+        run: lscpu | grep -E "Model name|Cache|Flags" | head -5 || true
+      - name: Compute bench scope
+        # Translate the changed-package directory names into lerna --scope
+        # flags so PRs only bench what they touched. Baseline runs (main /
+        # workflow_dispatch) get the full list from detect-changes, which
+        # makes this a no-op filter there.
+        id: scope
+        env:
+          BENCH: ${{ needs.detect-changes.outputs.bench }}
+        run: |
+          flags=""
+          for pkg in $(echo "$BENCH" | jq -r '.[]'); do
+            name=$(node -p "require('./packages/$pkg/package.json').name")
+            flags="$flags --scope $name"
+          done
+          echo "Bench scope flags:$flags"
+          echo "flags=$flags" >> "$GITHUB_OUTPUT"
       - name: Run CodSpeed benchmarks
         # CodSpeedHQ/action@v4 sets up CPU simulation (Cachegrind-based
         # instruction counting on a modeled CPU + cache hierarchy), runs
@@ -224,19 +404,111 @@ jobs:
         # Authenticates via GitHub OIDC (id-token: write above) so no
         # CODSPEED_TOKEN secret is needed.
         #
-        # mode: simulation (vs walltime) — we chose simulation because:
+        # mode: simulation — the blocking regression gate:
         #   - deterministic: <1% run-to-run drift (verified across 3
         #     runs of identical source)
-        #   - free CI minutes (walltime needs CodSpeed macro-runners)
+        #   - free CI minutes (runs on GitHub-hosted runners)
         #   - regression-detection signal is strong even though the
         #     headline numbers are MODELED instruction-time, not real
         #     wall-clock (JS-loop benches inflate 30-100x vs production
         #     V8 due to no JIT under Cachegrind; wasm decode kernels
         #     inflate ~5-15x; pure native ~1x)
+        # The codspeed-walltime job below complements this with real
+        # wall-clock measurements on CodSpeed macro runners.
         # See BENCHMARKING.md at the repo root for the full measurement
         # model, how to read the cold/warm bench split, and what the
         # CodSpeed dashboard warnings mean.
-        uses: CodSpeedHQ/action@v4
+        # Pinned to a full version (not the floating @v4) so the
+        # instrumentation environment stays identical between the main
+        # baseline and PR runs.
+        # Note: vitest 3's hard-coded 60s worker-RPC timer counts real
+        # seconds while valgrind slows the process ~60x, so large suites
+        # structurally trip "Timeout calling onTaskUpdate" AFTER their
+        # benches complete. The vitest configs set
+        # dangerouslyIgnoreUnhandledErrors when CODSPEED_RUNNER_MODE is
+        # "simulation" to keep that exit-code noise from failing the job
+        # (config-level because yarn 1 mangles `--`-forwarded CLI flags).
+        uses: CodSpeedHQ/action@v4.18.2
         with:
           mode: simulation
-          run: yarn run bench
+          run: yarn lerna run bench --parallel --stream ${{ steps.scope.outputs.flags }}
+
+  codspeed-walltime:
+    needs: [detect-changes, build]
+    # Gated behind a repository variable: a `runs-on: codspeed-macro` job
+    # queues forever (up to 24h) when macro runners aren't provisioned for
+    # the org, and GitHub's job timeout only covers execution, not queue
+    # time. Enable macro runners for the org on app.codspeed.io first
+    # (the repo is public — also make sure the runner group allows public
+    # repositories), then: gh variable set CODSPEED_MACRO_ENABLED --body true
+    if: needs.detect-changes.outputs.any == 'true' && vars.CODSPEED_MACRO_ENABLED == 'true'
+    # Advisory instrument: real wall-clock numbers (V8 JIT active, real
+    # cache/branch behavior) that complement the simulation gate above —
+    # simulation catches small algorithmic slips deterministically,
+    # walltime keeps the numbers honest on real hardware and covers the
+    # pure-JS packages where the no-JIT simulation model is furthest from
+    # production. Failures here must not block the PR while this beds in.
+    continue-on-error: true
+    timeout-minutes: 30
+    # CodSpeed-managed 16-core ARM64 bare-metal machine, tuned for
+    # low-noise walltime measurement. Requires the CodSpeed GitHub app on
+    # an organization account. NOTE: ARM64 — anything cached must be
+    # arch-qualified (see the cache key below).
+    runs-on: codspeed-macro
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - name: Download all built dists
+        uses: actions/download-artifact@v4
+        with:
+          pattern: dist-*
+          path: tmp/
+      - name: Replay dists into packages/<pkg>/dist
+        run: |
+          set -e
+          for d in tmp/dist-*; do
+            [ -d "$d" ] || continue
+            pkg=$(basename "$d" | sed 's/^dist-//')
+            mkdir -p "packages/$pkg/dist"
+            shopt -s dotglob nullglob
+            cp -r "$d"/* "packages/$pkg/dist/" 2>/dev/null || true
+          done
+      - name: Restore node_modules cache
+        id: modules-cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            packages/*/node_modules
+          # runner.arch matters: this job runs on ARM64 while every other
+          # job is x64; sharing a key would restore x64 native binaries
+          # (esbuild/rollup) and break vitest.
+          key: modules-node22-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('yarn.lock') }}
+      - name: Install dependencies
+        if: steps.modules-cache.outputs.cache-hit != 'true'
+        run: yarn install --frozen-lockfile
+      - name: Log CPU info
+        run: lscpu | grep -E "Model name|Cache|Flags" | head -5 || true
+      - name: Compute bench scope
+        id: scope
+        env:
+          BENCH: ${{ needs.detect-changes.outputs.bench }}
+        run: |
+          flags=""
+          for pkg in $(echo "$BENCH" | jq -r '.[]'); do
+            name=$(node -p "require('./packages/$pkg/package.json').name")
+            flags="$flags --scope $name"
+          done
+          echo "Bench scope flags:$flags"
+          echo "flags=$flags" >> "$GITHUB_OUTPUT"
+      - name: Run CodSpeed benchmarks (walltime)
+        # Walltime measures actual elapsed time, so parallel benchmark
+        # processes would contend for cores and add noise — run packages
+        # sequentially (--concurrency 1), unlike the simulation job where
+        # instruction counting is immune to contention.
+        uses: CodSpeedHQ/action@v4.18.2
+        with:
+          mode: walltime
+          run: yarn lerna run bench --concurrency 1 --stream ${{ steps.scope.outputs.flags }}
diff --git a/BENCHMARKING.md b/BENCHMARKING.md
index 802388a..94792eb 100644
--- a/BENCHMARKING.md
+++ b/BENCHMARKING.md
@@ -5,8 +5,9 @@ what the numbers mean, why they don't match real wall-clock time, and how
 to read warnings from the CodSpeed dashboard.
 
 Bench files live under `packages/*/bench/*.bench.js` and are driven by
-`vitest bench` + `@codspeed/vitest-plugin@^4`. The full pipeline is in
-`.github/workflows/pr-checks.yml` (job: `codspeed-bench`).
+`vitest bench` + `@codspeed/vitest-plugin@^5`. The full pipeline is in
+`.github/workflows/pr-checks.yml` (jobs: `codspeed-bench` and
+`codspeed-walltime`).
 
 ## TL;DR
 
@@ -21,10 +22,10 @@ Bench files live under `packages/*/bench/*.bench.js` and are driven by
   inflates 30–100× vs production V8; for wasm decode kernels it's ~5–15×;
   for pure compute it's roughly 1×.
 
-## Why simulation, not walltime
+## Two instruments: simulation is the gate, walltime is the reality check
 
 CodSpeed has two instruments: `simulation` (Cachegrind) and `walltime`
-(real CPU, statistical sampling on macro-runners).
+(real CPU, statistical sampling on macro-runners). We run **both**:
 
 | | Simulation | Walltime |
 |---|---|---|
@@ -36,9 +37,22 @@ CodSpeed has two instruments: `simulation` (Cachegrind) and `walltime`
 | Honest about JIT tier-up | No (depends on tier at bench time) | Yes |
 | Good for | Regression detection on a PR | Absolute production-like timing |
 
-We chose simulation because regression detection is the primary goal —
-catching "this PR slowed openjpeg by 5%" matters more than knowing the
-exact ms a user's browser will take.
+Simulation is the **blocking gate** because regression detection is the
+primary goal — catching "this PR slowed openjpeg by 5%" matters more than
+knowing the exact ms a user's browser will take, and simulation's <1%
+determinism flags small algorithmic slips that walltime noise would hide.
+
+Walltime runs as a **second, advisory instrument** (`codspeed-walltime`
+job, `continue-on-error: true`) on CodSpeed macro runners — 16-core ARM64
+bare-metal machines. It covers simulation's two blind spots: real-time
+effects (branch prediction, actual caches) that instruction counting
+models away, and the pure-JS packages (`little-endian`/`big-endian`)
+where the no-JIT simulation model is furthest from production V8.
+Walltime benches run packages sequentially (`--concurrency 1`) because
+parallel processes contend for cores and add noise; simulation is immune
+to contention so it keeps `--parallel`. Note the macro runners are ARM64:
+walltime numbers are real milliseconds, but on different silicon than
+most x86 production traffic.
 
 ## How the numbers get inflated
 
diff --git a/package.json b/package.json
index 9b21500..45bac7d 100644
--- a/package.json
+++ b/package.json
@@ -5,17 +5,19 @@
     "packages/*"
   ],
   "devDependencies": {
-    "@codspeed/vitest-plugin": "^4.0.1",
-    "@vitest/coverage-v8": "^2.1.8",
+    "@codspeed/vitest-plugin": "^5.7.1",
+    "@vitest/coverage-v8": "^3.2.4",
     "dotenv": "^14.1.0",
     "lerna": "^8.0.0",
-    "vitest": "^2.1.8"
+    "vitest": "^3.2.4",
+    "playwright-core": "^1.49.0"
   },
   "engines": {
     "node": ">=18"
   },
   "scripts": {
     "build:all": "lerna run build:ci --parallel --stream",
+    "test": "vitest run",
     "test:all": "lerna run test:ci --parallel --stream",
     "bench": "lerna run bench --parallel --stream",
     "bench:ci": "lerna run bench --parallel --stream",
diff --git a/packages/big-endian/bench/decode.bench.js b/packages/big-endian/bench/decode.bench.js
index 2ce4ec6..152d3ae 100644
--- a/packages/big-endian/bench/decode.bench.js
+++ b/packages/big-endian/bench/decode.bench.js
@@ -20,8 +20,14 @@ describe("big-endian decode (byte-swap)", () => {
     decode({ bitsAllocated: 16, pixelRepresentation: 1 }, data16)
   })
 
+  // The 16-bit benches above do real per-pixel swap work and are left
+  // unbatched. The 8-bit path is a bare property assignment, so a single
+  // call is swamped by fixed harness overhead and cache-model variation
+  // across runner CPUs; batch x100 so the body is measurable.
   const data8 = makeBuffer(SIZE_512x512)
-  bench("8-bit passthrough, 512x512", () => {
-    decode({ bitsAllocated: 8 }, data8)
+  bench("8-bit passthrough, 512x512 x100", () => {
+    for (let i = 0; i < 100; i++) {
+      decode({ bitsAllocated: 8 }, data8)
+    }
   })
 })
diff --git a/packages/big-endian/vitest.config.mjs b/packages/big-endian/vitest.config.mjs
index 70ce595..649a3ec 100644
--- a/packages/big-endian/vitest.config.mjs
+++ b/packages/big-endian/vitest.config.mjs
@@ -4,6 +4,18 @@ import codspeedPlugin from "@codspeed/vitest-plugin"
 export default defineConfig({
   plugins: [codspeedPlugin()],
   test: {
+    // Under the CodSpeed simulation instrument the entire process runs ~60x
+    // slower under valgrind while vitest's hard-coded 60s worker-RPC timer
+    // counts real seconds, so large bench suites structurally hit "Timeout
+    // calling onTaskUpdate" AFTER their benches complete and upload. Ignore
+    // that exit-code noise in simulation only; walltime and test runs stay
+    // strict.
+    // (CODSPEED_ENV is set whenever the CodSpeed runner is active; the
+    // mode string is "instrumentation" on older runners and "simulation"
+    // on newer ones, so match anything except walltime.)
+    dangerouslyIgnoreUnhandledErrors:
+      process.env.CODSPEED_ENV !== undefined &&
+      process.env.CODSPEED_RUNNER_MODE !== "walltime",
     name: "big-endian",
     include: ["test/**/*.test.js"],
     benchmark: {
diff --git a/packages/charls/bench/decode.bench.js b/packages/charls/bench/decode.bench.js
index d0f888c..372b4b4 100644
--- a/packages/charls/bench/decode.bench.js
+++ b/packages/charls/bench/decode.bench.js
@@ -59,7 +59,9 @@ let coldEnc
 let warmEnc
 if (!skip) {
   const factory = (await import(distPath)).default ?? (await import(distPath))
-  codec = await factory()
+  // Silence wasm stdout/stderr so vitest's console interception never runs
+  // inside a measured bench body (see openjphjs bench for details).
+  codec = await factory({ print: () => {}, printErr: () => {} })
 
   // Cold instances: one per fixture, constructed but never decoded.
   // The bench body will be the first decode call on this instance.
@@ -86,14 +88,21 @@ if (!skip) {
 }
 
 describe.skipIf(skip)("charls JPEG-LS (wasm)", () => {
-  bench("instantiate+destroy JpegLSDecoder", () => {
-    const d = new codec.JpegLSDecoder()
-    d.delete()
+  // Batched x50: a single instantiate+destroy is ~60 µs, where fixed harness
+  // overhead and cache-model variation across runner CPUs dominate; the loop
+  // puts the body in the ms range so the codec work is the signal.
+  bench("instantiate+destroy JpegLSDecoder x50", () => {
+    for (let i = 0; i < 50; i++) {
+      const d = new codec.JpegLSDecoder()
+      d.delete()
+    }
   })
 
-  bench("instantiate+destroy JpegLSEncoder", () => {
-    const e = new codec.JpegLSEncoder()
-    e.delete()
+  bench("instantiate+destroy JpegLSEncoder x50", () => {
+    for (let i = 0; i < 50; i++) {
+      const e = new codec.JpegLSEncoder()
+      e.delete()
+    }
   })
 
   bench("decode CT1.JLS (.80 lossless, 512x512x16bit) — cold", () => {
diff --git a/packages/charls/test/decode.test.js b/packages/charls/test/decode.test.js
index 9817e0d..aa275ff 100644
--- a/packages/charls/test/decode.test.js
+++ b/packages/charls/test/decode.test.js
@@ -8,14 +8,24 @@ const distDir = resolve(__dirname, "../dist")
 const fixturesDir = resolve(__dirname, "fixtures")
 
 const ct1Encoded = readFileSync(resolve(fixturesDir, "CT1.JLS"))
+// CT1.RAW is the lossless reference for CT1.JLS. The same slice ships as
+// openjpeg's CT1.RAW and openjphjs's CT1.RAW; charls, openjpeg and openjph
+// all decode their CT1 fixtures to these exact bytes, so the three codecs
+// cross-validate each other.
+const ct1Raw = readFileSync(resolve(fixturesDir, "CT1.RAW"))
 const ct2Encoded = readFileSync(resolve(fixturesDir, "CT2.JLS"))
 const ct2Raw = readFileSync(resolve(fixturesDir, "CT2.RAW"))
 // CT-512x512-near-lossless.JLS is a real .81 (JPEG-LS Lossy / Near-Lossless)
 // payload extracted from a Cornerstone3D test DICOM. Decoding exercises the
 // same charls codec but verifies the near-lossless code path (NEAR > 0).
+// Near-lossless decoding is deterministic, so the decoder's own output is
+// pinned as a regression golden (identical across all three build variants).
 const ctNearLossless = readFileSync(
   resolve(fixturesDir, "CT-512x512-near-lossless.JLS")
 )
+const ctNearLosslessRaw = readFileSync(
+  resolve(fixturesDir, "CT-512x512-near-lossless.RAW")
+)
 
 async function loadModule(modulePath) {
   const mod = await import(modulePath)
@@ -37,11 +47,17 @@ describe.each(buildVariants)("charls JPEG-LS decode — $name", ({ path, dist })
     if (isBuilt) codec = await loadModule(path)
   })
 
+  // In CI a missing dist means the build/artifact pipeline broke; fail loudly
+  // instead of letting every skipIf() below silently skip the suite.
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, `${dist} missing — build artifact was not replayed`).toBe(true)
+  })
+
   it.skipIf(!isBuilt)("exposes a version string", () => {
     expect(typeof codec.getVersion()).toBe("string")
   })
 
-  it.skipIf(!isBuilt)("decodes CT1.JLS to a 512x512 16-bit monochrome frame", () => {
+  it.skipIf(!isBuilt)("decodes CT1.JLS to bytes matching CT1.RAW (lossless)", () => {
     const decoder = new codec.JpegLSDecoder()
     decoder.getEncodedBuffer(ct1Encoded.length).set(ct1Encoded)
     decoder.decode()
@@ -53,7 +69,8 @@ describe.each(buildVariants)("charls JPEG-LS decode — $name", ({ path, dist })
     expect(frameInfo.componentCount).toBe(1)
 
     const decoded = decoder.getDecodedBuffer()
-    expect(decoded.length).toBe(512 * 512 * 2)
+    expect(decoded.length).toBe(ct1Raw.length)
+    expect(Buffer.from(decoded).equals(ct1Raw)).toBe(true)
 
     decoder.delete()
   })
@@ -71,7 +88,7 @@ describe.each(buildVariants)("charls JPEG-LS decode — $name", ({ path, dist })
   })
 
   it.skipIf(!isBuilt)(
-    "decodes a near-lossless CT JLS (transfer syntax .81)",
+    "decodes a near-lossless CT JLS (transfer syntax .81) matching the pinned golden output",
     () => {
       const decoder = new codec.JpegLSDecoder()
       decoder.getEncodedBuffer(ctNearLossless.length).set(ctNearLossless)
@@ -84,7 +101,8 @@ describe.each(buildVariants)("charls JPEG-LS decode — $name", ({ path, dist })
       expect(frameInfo.componentCount).toBe(1)
 
       const decoded = decoder.getDecodedBuffer()
-      expect(decoded.length).toBe(512 * 512 * 2)
+      expect(decoded.length).toBe(ctNearLosslessRaw.length)
+      expect(Buffer.from(decoded).equals(ctNearLosslessRaw)).toBe(true)
       decoder.delete()
     }
   )
@@ -114,8 +132,11 @@ describe.each(encoderVariants)(
       encoder.setNearLossless(0)
       encoder.encode()
       const encoded = encoder.getEncodedBuffer()
-      expect(encoded.length).toBeGreaterThan(0)
-      expect(encoded.length).toBeLessThan(ct2Raw.length)
+      // Compression-quality regression bounds. Measured 115504 bytes on
+      // 2026-07-07 (emsdk 3.1.74): the ceiling catches an encoder that
+      // regresses compression ratio; the floor catches silent truncation.
+      expect(encoded.length).toBeGreaterThan(115504 * 0.5)
+      expect(encoded.length).toBeLessThan(115504 * 1.10)
 
       const decoder = new codec.JpegLSDecoder()
       decoder.getEncodedBuffer(encoded.length).set(encoded)
diff --git a/packages/charls/test/fixtures/CT-512x512-near-lossless.RAW b/packages/charls/test/fixtures/CT-512x512-near-lossless.RAW
new file mode 100644
index 0000000..f71d752
Binary files /dev/null and b/packages/charls/test/fixtures/CT-512x512-near-lossless.RAW differ
diff --git a/packages/charls/test/fixtures/CT1.RAW b/packages/charls/test/fixtures/CT1.RAW
new file mode 100644
index 0000000..92cca6a
Binary files /dev/null and b/packages/charls/test/fixtures/CT1.RAW differ
diff --git a/packages/charls/test/fixtures/CT2-gray16u.jls b/packages/charls/test/fixtures/CT2-gray16u.jls
new file mode 100644
index 0000000..31e5c05
Binary files /dev/null and b/packages/charls/test/fixtures/CT2-gray16u.jls differ
diff --git a/packages/charls/test/fixtures/CT2-gray8.jls b/packages/charls/test/fixtures/CT2-gray8.jls
new file mode 100644
index 0000000..d21cfc8
Binary files /dev/null and b/packages/charls/test/fixtures/CT2-gray8.jls differ
diff --git a/packages/charls/test/fixtures/US1-color-ilv-sample.jls b/packages/charls/test/fixtures/US1-color-ilv-sample.jls
new file mode 100644
index 0000000..d1ae830
Binary files /dev/null and b/packages/charls/test/fixtures/US1-color-ilv-sample.jls differ
diff --git a/packages/charls/test/heap-stability.test.js b/packages/charls/test/heap-stability.test.js
new file mode 100644
index 0000000..6245a8f
--- /dev/null
+++ b/packages/charls/test/heap-stability.test.js
@@ -0,0 +1,87 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "charlswasm.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+// Emscripten heaps grow but never shrink, so a native-side leak shows up as
+// monotonic HEAP8 growth across repeated use — invisible to single-decode
+// tests, an OOM after thousands of frames in a viewer. This repo has a
+// history of exactly that class of bug (error-path instance leaks, encoder
+// handle leaks).
+//
+// Loop sizing matters: the arena starts at 50 MiB (INITIAL_MEMORY) with
+// ALLOW_MEMORY_GROWTH, so a leak only becomes visible once the leaked
+// instances exceed the arena's free slack. Measured: 100 leaked decoder
+// instances grow HEAP8 by ~22 MiB — comfortably detectable — while 100
+// correct decode/delete cycles leave capacity byte-identical. (Verified by
+// deleting the delete() call: the assertion fails.)
+describe("charls wasm heap stability", { timeout: 120000 }, () => {
+  let codec
+  const encoded = readFileSync(resolve(fixturesDir, "CT1.JLS"))
+  const raw = readFileSync(resolve(fixturesDir, "CT2.RAW"))
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/charlswasm.js")
+  })
+
+  it.skipIf(!isBuilt)("repeated decode/delete cycles do not grow the heap", () => {
+    const decodeOnce = () => {
+      const decoder = new codec.JpegLSDecoder()
+      decoder.getEncodedBuffer(encoded.length).set(encoded)
+      decoder.decode()
+      decoder.delete()
+    }
+    for (let i = 0; i < 10; i++) decodeOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 100; i++) decodeOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+
+  it.skipIf(!isBuilt)("repeated encode/delete cycles do not grow the heap", () => {
+    const encodeOnce = () => {
+      const encoder = new codec.JpegLSEncoder()
+      encoder.getDecodedBuffer({ width: 512, height: 512, bitsPerSample: 16, componentCount: 1 }).set(raw)
+      encoder.setNearLossless(0)
+      encoder.encode()
+      encoder.delete()
+    }
+    for (let i = 0; i < 10; i++) encodeOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 60; i++) encodeOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+
+  it.skipIf(!isBuilt)("repeated failing decodes do not grow the heap", () => {
+    // Garbage (not truncated-after-valid-header) input: fails fast at
+    // header parse instead of spending seconds in sample recovery, so the
+    // loop can be large enough for a leak to exceed the arena slack.
+    const garbage = new Uint8Array(64)
+    for (let i = 0; i < garbage.length; i++) garbage[i] = (i * 37 + 11) % 256
+    const failOnce = () => {
+      const decoder = new codec.JpegLSDecoder()
+      decoder.getEncodedBuffer(garbage.length).set(garbage)
+      try {
+        decoder.decode()
+      } catch {
+        // expected for malformed input
+      }
+      decoder.delete()
+    }
+    for (let i = 0; i < 10; i++) failOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 100; i++) failOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+})
diff --git a/packages/charls/test/matrix.test.js b/packages/charls/test/matrix.test.js
new file mode 100644
index 0000000..a09972f
--- /dev/null
+++ b/packages/charls/test/matrix.test.js
@@ -0,0 +1,126 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { createHash } from "node:crypto"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+import { gray8FromCT2, gray16uFromCT2 } from "../../../tools/fixture-verification/gen/derive.mjs"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "charlsjs.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+const asBuffer = (ta) => Buffer.from(ta.buffer, ta.byteOffset, ta.byteLength)
+
+// Color and bit-depth coverage beyond the 16-bit signed CT profile that
+// decode.test.js pins.
+//
+// Fixture provenance (tools/fixture-verification/gen/generate-fixtures.mjs):
+// - US1-color-ilv-sample.jls: US1.RAW (640x480 interleaved RGB ultrasound
+//   frame shipped in the openjpeg package) encoded losslessly with
+//   interleave mode 2 (sample). Lossless => the reference is the source
+//   itself. Independently verified byte-identical by pylibjpeg-libjpeg
+//   (Thomas Richter's libjpeg — a JPEG-LS implementation independent of
+//   CharLS) on 2026-07-07.
+// - CT2-gray8.jls / CT2-gray16u.jls: deterministic transforms of CT2.RAW
+//   (see derive.mjs), encoded losslessly; tests re-derive the reference.
+// - SC1.JLS: shipped 12-bit fixture; decoded output verified byte-exact by
+//   pylibjpeg-libjpeg and cross-codec against openjphjs/openjpeg SC1
+//   encodings, pinned by SHA-256.
+describe("charls JPEG-LS decode matrix — color and bit depths", () => {
+  let codec
+  const us1 = readFileSync(resolve(__dirname, "../../openjpeg/test/fixtures/raw/US1.RAW"))
+  const ct2 = readFileSync(resolve(fixturesDir, "CT2.RAW"))
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/charlsjs.js")
+  })
+
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, "charlsjs.js missing — build artifact was not replayed").toBe(true)
+  })
+
+  const decode = (file) => {
+    const encoded = readFileSync(resolve(fixturesDir, file))
+    const decoder = new codec.JpegLSDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decode()
+    const frameInfo = decoder.getFrameInfo()
+    const out = Buffer.from(decoder.getDecodedBuffer())
+    decoder.delete()
+    return { frameInfo, out }
+  }
+
+  it.skipIf(!isBuilt)("decodes 3-component interleaved color losslessly (ILV=sample)", () => {
+    const { frameInfo, out } = decode("US1-color-ilv-sample.jls")
+    expect(frameInfo.componentCount).toBe(3)
+    expect(frameInfo.width).toBe(640)
+    expect(frameInfo.height).toBe(480)
+    expect(frameInfo.bitsPerSample).toBe(8)
+    expect(out.equals(us1)).toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("decodes 8-bit grayscale losslessly", () => {
+    const { frameInfo, out } = decode("CT2-gray8.jls")
+    expect(frameInfo.bitsPerSample).toBe(8)
+    expect(out.equals(asBuffer(gray8FromCT2(ct2)))).toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("decodes 16-bit unsigned losslessly", () => {
+    const { frameInfo, out } = decode("CT2-gray16u.jls")
+    expect(frameInfo.bitsPerSample).toBe(16)
+    expect(out.equals(asBuffer(gray16uFromCT2(ct2)))).toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("near-lossless encode honors the spec error bound (maxAbsDiff <= NEAR)", () => {
+    // T.87 guarantees every reconstructed sample is within NEAR of the
+    // source — an exact spec bound, not a heuristic tolerance.
+    for (const near of [1, 2, 3]) {
+      const encoder = new codec.JpegLSEncoder()
+      encoder.getDecodedBuffer({ width: 512, height: 512, bitsPerSample: 16, componentCount: 1 }).set(ct2)
+      encoder.setNearLossless(near)
+      encoder.encode()
+      const encoded = Buffer.from(encoder.getEncodedBuffer())
+      encoder.delete()
+
+      const decoder = new codec.JpegLSDecoder()
+      decoder.getEncodedBuffer(encoded.length).set(encoded)
+      decoder.decode()
+      const out = Buffer.from(decoder.getDecodedBuffer())
+      decoder.delete()
+
+      const src16 = new Int16Array(ct2.buffer, ct2.byteOffset, ct2.length / 2)
+      const out16 = new Int16Array(out.buffer, out.byteOffset, out.length / 2)
+      let maxAbsDiff = 0
+      for (let i = 0; i < src16.length; i++) {
+        const diff = Math.abs(out16[i] - src16[i])
+        if (diff > maxAbsDiff) maxAbsDiff = diff
+      }
+      expect(maxAbsDiff).toBeLessThanOrEqual(near)
+      expect(maxAbsDiff).toBeGreaterThan(0) // actually lossy, not accidentally lossless
+    }
+  })
+
+  it.skipIf(!isBuilt)("decodes the shipped 12-bit SC1 fixture to the pinned pixels", () => {
+    const { frameInfo, out } = decode("SC1.JLS")
+    expect(frameInfo.width).toBe(2048)
+    expect(frameInfo.height).toBe(2487)
+    expect(frameInfo.bitsPerSample).toBe(12)
+    expect(frameInfo.componentCount).toBe(1)
+    // Golden pinned by hash (a 10 MB RAW is not worth committing). Verified
+    // three ways (2026-07-07): pylibjpeg-libjpeg (independent JPEG-LS
+    // implementation) agrees on all 5,093,376 samples, and the same image's
+    // HTJ2K (SC1.j2c) and J2K (SC1.j2k) encodings decode to these exact
+    // bytes in openjphjs and openjpeg — three codecs, one pixel truth.
+    expect(createHash("sha256").update(out).digest("hex")).toBe(
+      "1c8e43cef2a3b25b5304c3dd1732e64c2f44d05d342387ea8e15ce01ec793c32"
+    )
+  })
+})
diff --git a/packages/charls/vitest.config.mjs b/packages/charls/vitest.config.mjs
index 50bd901..0cdf45b 100644
--- a/packages/charls/vitest.config.mjs
+++ b/packages/charls/vitest.config.mjs
@@ -4,6 +4,18 @@ import codspeedPlugin from "@codspeed/vitest-plugin"
 export default defineConfig({
   plugins: [codspeedPlugin()],
   test: {
+    // Under the CodSpeed simulation instrument the entire process runs ~60x
+    // slower under valgrind while vitest's hard-coded 60s worker-RPC timer
+    // counts real seconds, so large bench suites structurally hit "Timeout
+    // calling onTaskUpdate" AFTER their benches complete and upload. Ignore
+    // that exit-code noise in simulation only; walltime and test runs stay
+    // strict.
+    // (CODSPEED_ENV is set whenever the CodSpeed runner is active; the
+    // mode string is "instrumentation" on older runners and "simulation"
+    // on newer ones, so match anything except walltime.)
+    dangerouslyIgnoreUnhandledErrors:
+      process.env.CODSPEED_ENV !== undefined &&
+      process.env.CODSPEED_RUNNER_MODE !== "walltime",
     name: "charls",
     include: ["test/**/*.test.js"],
     benchmark: {
diff --git a/packages/dicom-codec/bench/dispatch.bench.js b/packages/dicom-codec/bench/dispatch.bench.js
index 3e368fa..03ae8d3 100644
--- a/packages/dicom-codec/bench/dispatch.bench.js
+++ b/packages/dicom-codec/bench/dispatch.bench.js
@@ -105,3 +105,20 @@ describe.skipIf(skip)("dicom-codec dispatch", () => {
     })
   }
 })
+
+describe.skipIf(skip)("dicom-codec encode/transcode dispatch", () => {
+  const ct1Raw = skip ? null : read("openjpeg/test/fixtures/raw/CT1.RAW")
+  const ct1Jls = skip ? null : read("charls/test/fixtures/CT1.JLS")
+
+  bench("encode to JPEG-LS Lossless (.80)", async () => {
+    await dicomCodec.encode(new Uint8Array(ct1Raw), ctSigned512, "1.2.840.10008.1.2.4.80")
+  })
+
+  bench("encode to JPEG 2000 Lossless (.90)", async () => {
+    await dicomCodec.encode(new Uint8Array(ct1Raw), ctSigned512, "1.2.840.10008.1.2.4.90")
+  })
+
+  bench("transcode JPEG-LS -> J2K (.80 -> .90)", async () => {
+    await dicomCodec.transcode(ct1Jls, ctSigned512, "1.2.840.10008.1.2.4.80", "1.2.840.10008.1.2.4.90")
+  })
+})
diff --git a/packages/dicom-codec/test/color-and-depth.test.js b/packages/dicom-codec/test/color-and-depth.test.js
new file mode 100644
index 0000000..00d9c0d
--- /dev/null
+++ b/packages/dicom-codec/test/color-and-depth.test.js
@@ -0,0 +1,75 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+import { gray8FromCT2 } from "../../../tools/fixture-verification/gen/derive.mjs"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const packagesRoot = resolve(__dirname, "../..")
+
+const REQUIRED = [
+  "libjpeg-turbo-8bit/dist/libjpegturbojs.js",
+  "charls/dist/charlsjs.js",
+]
+const ALL_BUILT = REQUIRED.every((p) => existsSync(resolve(packagesRoot, p)))
+
+function frameBytes(imageFrame) {
+  return Buffer.from(imageFrame.buffer, imageFrame.byteOffset ?? 0, imageFrame.byteLength)
+}
+
+it.runIf(process.env.CI)("sibling codec dists are present in CI (color/depth suite)", () => {
+  expect(ALL_BUILT, "codec dists missing — artifacts not replayed").toBe(true)
+})
+
+// Color and non-16-bit paths through the dispatcher. Every reference is
+// either a DCMTK-verified golden (color JPEG), the lossless source itself
+// (RLE, JLS), or a deterministic derivation (derive.mjs).
+describe.skipIf(!ALL_BUILT)("dicom-codec color and bit-depth dispatch", () => {
+  let dicomCodec
+  const us1 = readFileSync(resolve(packagesRoot, "openjpeg/test/fixtures/raw/US1.RAW"))
+
+  beforeAll(async () => {
+    const mod = await import("../src/index.js")
+    dicomCodec = mod.default ?? mod
+  })
+
+  it("decodes a color 4:2:0 JPEG (.50, samplesPerPixel 3) to the DCMTK-verified pixels", async () => {
+    const jpegBytes = readFileSync(
+      resolve(packagesRoot, "libjpeg-turbo-8bit/test/fixtures/jpeg/US1-color-420.jpg")
+    )
+    const golden = readFileSync(
+      resolve(packagesRoot, "libjpeg-turbo-8bit/test/fixtures/raw/US1-color-420.raw")
+    )
+    const result = await dicomCodec.decode(
+      jpegBytes,
+      { rows: 480, columns: 640, bitsAllocated: 8, samplesPerPixel: 3, pixelRepresentation: 0, signed: false },
+      "1.2.840.10008.1.2.4.50"
+    )
+    expect(result.imageFrame.byteLength).toBe(640 * 480 * 3)
+    expect(frameBytes(result.imageFrame).equals(golden)).toBe(true)
+  })
+
+  it("decodes color RLE (3 segments) interleaved when planarConfiguration is 0", async () => {
+    const rleBytes = readFileSync(
+      resolve(packagesRoot, "dicom-codec/test/fixtures/rle/US1-color.rle")
+    )
+    const result = await dicomCodec.decode(
+      new Uint8Array(rleBytes),
+      { rows: 480, columns: 640, bitsAllocated: 8, samplesPerPixel: 3, planarConfiguration: 0 },
+      "1.2.840.10008.1.2.5"
+    )
+    expect(frameBytes(result.imageFrame).equals(us1)).toBe(true)
+  })
+
+  it("decodes an 8-bit JPEG-LS (.80) through the dispatcher losslessly", async () => {
+    const jls = readFileSync(resolve(packagesRoot, "charls/test/fixtures/CT2-gray8.jls"))
+    const ct2 = readFileSync(resolve(packagesRoot, "charls/test/fixtures/CT2.RAW"))
+    const expected = gray8FromCT2(ct2)
+    const result = await dicomCodec.decode(
+      jls,
+      { rows: 512, columns: 512, bitsAllocated: 8, samplesPerPixel: 1, pixelRepresentation: 0, signed: false },
+      "1.2.840.10008.1.2.4.80"
+    )
+    expect(frameBytes(result.imageFrame).equals(Buffer.from(expected.buffer, 0, expected.byteLength))).toBe(true)
+  })
+})
diff --git a/packages/dicom-codec/test/dispatch.test.js b/packages/dicom-codec/test/dispatch.test.js
index 8f58634..1169a57 100644
--- a/packages/dicom-codec/test/dispatch.test.js
+++ b/packages/dicom-codec/test/dispatch.test.js
@@ -37,6 +37,15 @@ const SUPPORTED_UIDS = [
   "1.2.840.10008.1.2.5",
 ]
 
+// In CI a missing sibling dist means the build/artifact pipeline broke; fail
+// loudly instead of letting describe.skipIf() silently skip the whole suite.
+it.runIf(process.env.CI)("required sibling builds are present in CI", () => {
+  const missing = REQUIRED_BUILDS.filter(
+    (p) => !existsSync(resolve(packagesRoot, p))
+  )
+  expect(missing, `missing dists: ${missing.join(", ")}`).toEqual([])
+})
+
 describe.skipIf(!ALL_BUILT)("dicom-codec dispatcher", () => {
   let dicomCodec
 
diff --git a/packages/dicom-codec/test/fixtures/raw/CT-512x512.raw b/packages/dicom-codec/test/fixtures/raw/CT-512x512.raw
new file mode 100644
index 0000000..7b44b87
Binary files /dev/null and b/packages/dicom-codec/test/fixtures/raw/CT-512x512.raw differ
diff --git a/packages/dicom-codec/test/fixtures/rle/US1-color.rle b/packages/dicom-codec/test/fixtures/rle/US1-color.rle
new file mode 100644
index 0000000..343e959
Binary files /dev/null and b/packages/dicom-codec/test/fixtures/rle/US1-color.rle differ
diff --git a/packages/dicom-codec/test/integration.test.js b/packages/dicom-codec/test/integration.test.js
index b931898..8f21b36 100644
--- a/packages/dicom-codec/test/integration.test.js
+++ b/packages/dicom-codec/test/integration.test.js
@@ -22,6 +22,22 @@ const OPENJPH_BUILT = existsSync(
 const ALL_BUILT =
   LIBJPEG_8BIT_BUILT && CHARLS_BUILT && OPENJPEG_BUILT && OPENJPH_BUILT
 
+// Byte view over a decoded imageFrame regardless of its typed-array flavor
+// (Uint8Array, Uint16Array, Int16Array, ...).
+function frameBytes(imageFrame) {
+  return Buffer.from(
+    imageFrame.buffer,
+    imageFrame.byteOffset ?? 0,
+    imageFrame.byteLength
+  )
+}
+
+// In CI a missing sibling dist means the build/artifact pipeline broke; fail
+// loudly instead of letting describe.skipIf() silently skip the whole suite.
+it.runIf(process.env.CI)("sibling codec dists are present in CI", () => {
+  expect(ALL_BUILT, "one or more codec dists missing — artifacts not replayed").toBe(true)
+})
+
 describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
   let dicomCodec
 
@@ -37,8 +53,11 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
         "libjpeg-turbo-8bit/test/fixtures/jpeg/jpeg400jfif.jpg"
       )
     )
+    const jpegRaw = readFileSync(
+      resolve(packagesRoot, "libjpeg-turbo-8bit/test/fixtures/raw/jpeg400jfif.raw")
+    )
 
-    it("decodes through the dispatcher", async () => {
+    it("decodes through the dispatcher to the exact reference pixels", async () => {
       const imageInfo = {
         rows: 800,
         columns: 600,
@@ -55,6 +74,7 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
       )
 
       expect(result.imageFrame.byteLength).toBe(600 * 800)
+      expect(frameBytes(result.imageFrame).equals(jpegRaw)).toBe(true)
       expect(result.imageInfo.width).toBe(600)
       expect(result.imageInfo.height).toBe(800)
       expect(typeof result.processInfo.duration).toBe("number")
@@ -65,8 +85,11 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
     const jlsBytes = readFileSync(
       resolve(packagesRoot, "charls/test/fixtures/CT1.JLS")
     )
+    const jlsRaw = readFileSync(
+      resolve(packagesRoot, "charls/test/fixtures/CT1.RAW")
+    )
 
-    it("decodes through the dispatcher", async () => {
+    it("decodes through the dispatcher to the exact reference pixels", async () => {
       const imageInfo = {
         rows: 512,
         columns: 512,
@@ -83,6 +106,7 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
       )
 
       expect(result.imageFrame.byteLength).toBe(512 * 512 * 2)
+      expect(frameBytes(result.imageFrame).equals(jlsRaw)).toBe(true)
       expect(result.imageInfo.width).toBe(512)
       expect(result.imageInfo.height).toBe(512)
     })
@@ -92,8 +116,11 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
     const j2kBytes = readFileSync(
       resolve(packagesRoot, "openjpeg/test/fixtures/j2k/CT1.j2k")
     )
+    const j2kRaw = readFileSync(
+      resolve(packagesRoot, "openjpeg/test/fixtures/raw/CT1.RAW")
+    )
 
-    it("decodes through the dispatcher", async () => {
+    it("decodes through the dispatcher to the exact reference pixels", async () => {
       const imageInfo = {
         rows: 512,
         columns: 512,
@@ -110,6 +137,7 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
       )
 
       expect(result.imageFrame.byteLength).toBe(512 * 512 * 2)
+      expect(frameBytes(result.imageFrame).equals(j2kRaw)).toBe(true)
       expect(result.imageInfo.width).toBe(512)
       expect(result.imageInfo.height).toBe(512)
     })
@@ -119,8 +147,11 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
     const j2cBytes = readFileSync(
       resolve(packagesRoot, "openjphjs/test/fixtures/j2c/CT1.j2c")
     )
+    const j2cRaw = readFileSync(
+      resolve(packagesRoot, "openjphjs/test/fixtures/raw/CT1.RAW")
+    )
 
-    it("decodes through the dispatcher", async () => {
+    it("decodes through the dispatcher to the exact reference pixels", async () => {
       const imageInfo = {
         rows: 512,
         columns: 512,
@@ -137,6 +168,7 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
       )
 
       expect(result.imageFrame.byteLength).toBe(512 * 512 * 2)
+      expect(frameBytes(result.imageFrame).equals(j2cRaw)).toBe(true)
       expect(result.imageInfo.width).toBe(512)
       expect(result.imageInfo.height).toBe(512)
     })
@@ -145,7 +177,10 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
   describe("JPEG Lossless (1.2.840.10008.1.2.4.57 / .70)", () => {
     // These go through dicom-codec's internal jpegLosslessCodec
     // (jpeg-lossless-decoder-js, pure JS — no separate wasm package). Both
-    // fixtures decode the same 512x512x16 CT slice.
+    // fixtures encode the same 512x512x16 CT slice; the reference
+    // fixtures/raw/CT-512x512.raw was cross-validated three ways: the RLE
+    // decoder, the Process 14 path of jpeg-lossless-decoder-js and DCMTK's
+    // dcmdjpeg all produce these exact bytes.
     const jpllProcess14 = readFileSync(
       resolve(
         packagesRoot,
@@ -158,6 +193,9 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
         "dicom-codec/test/fixtures/jpeg-lossless/CT-512x512-process14-sv1.jpll"
       )
     )
+    const ctRaw = readFileSync(
+      resolve(packagesRoot, "dicom-codec/test/fixtures/raw/CT-512x512.raw")
+    )
 
     const ctImageInfo = {
       rows: 512,
@@ -168,32 +206,59 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
       signed: true,
     }
 
-    it("decodes Process 14 through the dispatcher (.57)", async () => {
+    it("decodes Process 14 through the dispatcher (.57) to the exact reference pixels", async () => {
       const result = await dicomCodec.decode(
         jpllProcess14,
         ctImageInfo,
         "1.2.840.10008.1.2.4.57"
       )
-      expect(result.imageFrame.byteLength).toBe(512 * 512 * 2)
+      expect(result.imageFrame.byteLength).toBe(ctRaw.length)
+      expect(frameBytes(result.imageFrame).equals(ctRaw)).toBe(true)
     })
 
-    it("decodes Process 14 SV1 through the dispatcher (.70)", async () => {
+    // KNOWN UPSTREAM BUG (jpeg-lossless-decoder-js): the SV1 path decodes
+    // the final pixel of this fixture as 0 instead of -2000. DCMTK's
+    // dcmdjpeg confirms the fixture itself is correct (its decode matches
+    // CT-512x512.raw exactly, last pixel included), so the defect is in the
+    // JS decoder. The test below pins today's behavior: every sample except
+    // the last matches the reference. When the upstream bug is fixed, the
+    // paired `it.fails` test starts passing and vitest will flag it — then
+    // fold these two tests into a single exact comparison.
+    it("decodes Process 14 SV1 through the dispatcher (.70) — all but the last pixel match", async () => {
       const result = await dicomCodec.decode(
         jpllProcess14Sv1,
         ctImageInfo,
         "1.2.840.10008.1.2.4.70"
       )
-      expect(result.imageFrame.byteLength).toBe(512 * 512 * 2)
+      expect(result.imageFrame.byteLength).toBe(ctRaw.length)
+
+      const actual = frameBytes(result.imageFrame)
+      // Everything up to the final 16-bit sample must match exactly.
+      expect(actual.subarray(0, ctRaw.length - 2).equals(ctRaw.subarray(0, ctRaw.length - 2))).toBe(true)
+    })
+
+    it.fails("decodes Process 14 SV1 (.70) to the exact reference pixels (known upstream last-pixel bug)", async () => {
+      const result = await dicomCodec.decode(
+        jpllProcess14Sv1,
+        ctImageInfo,
+        "1.2.840.10008.1.2.4.70"
+      )
+      expect(frameBytes(result.imageFrame).equals(ctRaw)).toBe(true)
     })
   })
 
   describe("RLE Lossless (1.2.840.10008.1.2.5)", () => {
-    // Routed to dicom-codec's internal rleLossless.js (pure JS).
+    // Routed to dicom-codec's internal rleLossless.js (pure JS). The RAW
+    // reference is cross-validated: the JPEG Lossless Process 14 decode of
+    // the same slice and DCMTK both produce these exact bytes.
     const rleBytes = readFileSync(
       resolve(packagesRoot, "dicom-codec/test/fixtures/rle/CT-512x512.rle")
     )
+    const ctRaw = readFileSync(
+      resolve(packagesRoot, "dicom-codec/test/fixtures/raw/CT-512x512.raw")
+    )
 
-    it("decodes through the dispatcher", async () => {
+    it("decodes through the dispatcher to the exact reference pixels", async () => {
       const imageInfo = {
         rows: 512,
         columns: 512,
@@ -209,7 +274,8 @@ describe.skipIf(!ALL_BUILT)("dicom-codec integration", () => {
         "1.2.840.10008.1.2.5"
       )
 
-      expect(result.imageFrame.byteLength).toBe(512 * 512 * 2)
+      expect(result.imageFrame.byteLength).toBe(ctRaw.length)
+      expect(frameBytes(result.imageFrame).equals(ctRaw)).toBe(true)
     })
   })
 })
diff --git a/packages/dicom-codec/test/transcode-and-pixeldata.test.js b/packages/dicom-codec/test/transcode-and-pixeldata.test.js
new file mode 100644
index 0000000..e2fef74
--- /dev/null
+++ b/packages/dicom-codec/test/transcode-and-pixeldata.test.js
@@ -0,0 +1,77 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const packagesRoot = resolve(__dirname, "../..")
+
+const REQUIRED = [
+  "charls/dist/charlsjs.js",
+]
+const ALL_BUILT = REQUIRED.every((p) => existsSync(resolve(packagesRoot, p)))
+
+function frameBytes(imageFrame) {
+  return Buffer.from(imageFrame.buffer, imageFrame.byteOffset ?? 0, imageFrame.byteLength)
+}
+
+it.runIf(process.env.CI)("sibling codec dists are present in CI (transcode suite)", () => {
+  expect(ALL_BUILT, "codec dists missing — artifacts not replayed").toBe(true)
+})
+
+describe.skipIf(!ALL_BUILT)("dicom-codec encode", () => {
+  let dicomCodec
+  const ct1Raw = readFileSync(resolve(packagesRoot, "openjpeg/test/fixtures/raw/CT1.RAW"))
+  const ctImageInfo = {
+    rows: 512,
+    columns: 512,
+    bitsAllocated: 16,
+    samplesPerPixel: 1,
+    pixelRepresentation: 1,
+    signed: true,
+  }
+
+  beforeAll(async () => {
+    const mod = await import("../src/index.js")
+    dicomCodec = mod.default ?? mod
+  })
+
+  it("encode() to JPEG-LS Lossless (.80) round-trips byte-exact", async () => {
+    const encoded = await dicomCodec.encode(new Uint8Array(ct1Raw), ctImageInfo, "1.2.840.10008.1.2.4.80")
+    const decoded = await dicomCodec.decode(encoded.imageFrame, ctImageInfo, "1.2.840.10008.1.2.4.80")
+    expect(frameBytes(decoded.imageFrame).equals(ct1Raw)).toBe(true)
+  })
+})
+
+describe.skipIf(!ALL_BUILT)("dicom-codec getPixelData typed-array contract", () => {
+  let dicomCodec
+  const ct1Jls = readFileSync(resolve(packagesRoot, "charls/test/fixtures/CT1.JLS"))
+
+  beforeAll(async () => {
+    const mod = await import("../src/index.js")
+    dicomCodec = mod.default ?? mod
+  })
+
+  // Pins the constructor returned per (bitsAllocated, pixelRepresentation)
+  // for the JPEG-LS codec path — the contract plan 008 hardens.
+  it.each([
+    { bitsAllocated: 16, pixelRepresentation: 1, ctor: "Int16Array" },
+    { bitsAllocated: 16, pixelRepresentation: 0, ctor: "Uint16Array" },
+  ])(
+    "returns $ctor for bitsAllocated=$bitsAllocated pixelRepresentation=$pixelRepresentation",
+    async ({ bitsAllocated, pixelRepresentation, ctor }) => {
+      const imageInfo = {
+        rows: 512,
+        columns: 512,
+        bitsAllocated,
+        samplesPerPixel: 1,
+        pixelRepresentation,
+        signed: pixelRepresentation === 1,
+      }
+      const decoded = await dicomCodec.decode(ct1Jls, imageInfo, "1.2.840.10008.1.2.4.80")
+      const pixelData = dicomCodec.getPixelData(decoded.imageFrame, imageInfo, "1.2.840.10008.1.2.4.80")
+      expect(pixelData.constructor.name).toBe(ctor)
+      expect(pixelData.length).toBe(512 * 512)
+    }
+  )
+})
diff --git a/packages/dicom-codec/vitest.config.mjs b/packages/dicom-codec/vitest.config.mjs
index 2939469..f71bed6 100644
--- a/packages/dicom-codec/vitest.config.mjs
+++ b/packages/dicom-codec/vitest.config.mjs
@@ -4,6 +4,18 @@ import codspeedPlugin from "@codspeed/vitest-plugin"
 export default defineConfig({
   plugins: [codspeedPlugin()],
   test: {
+    // Under the CodSpeed simulation instrument the entire process runs ~60x
+    // slower under valgrind while vitest's hard-coded 60s worker-RPC timer
+    // counts real seconds, so large bench suites structurally hit "Timeout
+    // calling onTaskUpdate" AFTER their benches complete and upload. Ignore
+    // that exit-code noise in simulation only; walltime and test runs stay
+    // strict.
+    // (CODSPEED_ENV is set whenever the CodSpeed runner is active; the
+    // mode string is "instrumentation" on older runners and "simulation"
+    // on newer ones, so match anything except walltime.)
+    dangerouslyIgnoreUnhandledErrors:
+      process.env.CODSPEED_ENV !== undefined &&
+      process.env.CODSPEED_RUNNER_MODE !== "walltime",
     name: "dicom-codec",
     include: ["test/**/*.test.js"],
     benchmark: {
diff --git a/packages/libjpeg-turbo-12bit/test/fixtures/raw/CT-512x512-12bit.raw b/packages/libjpeg-turbo-12bit/test/fixtures/raw/CT-512x512-12bit.raw
new file mode 100644
index 0000000..9724244
Binary files /dev/null and b/packages/libjpeg-turbo-12bit/test/fixtures/raw/CT-512x512-12bit.raw differ
diff --git a/packages/libjpeg-turbo-8bit/bench/decode.bench.js b/packages/libjpeg-turbo-8bit/bench/decode.bench.js
index 93d6ffe..09df187 100644
--- a/packages/libjpeg-turbo-8bit/bench/decode.bench.js
+++ b/packages/libjpeg-turbo-8bit/bench/decode.bench.js
@@ -57,7 +57,9 @@ let coldEnc
 let warmEnc
 if (!skip) {
   const factory = (await import(distPath)).default ?? (await import(distPath))
-  codec = await factory()
+  // Silence wasm stdout/stderr so vitest's console interception never runs
+  // inside a measured bench body (see openjphjs bench for details).
+  codec = await factory({ print: () => {}, printErr: () => {} })
 
   // Cold instances: just construct, never decode/encode at module load.
   // The bench body will be the first call into the decoder/encoder.
@@ -81,14 +83,21 @@ if (!skip) {
 }
 
 describe.skipIf(skip)("libjpeg-turbo-8bit (wasm)", () => {
-  bench("instantiate+destroy JPEGDecoder", () => {
-    const d = new codec.JPEGDecoder()
-    d.delete()
+  // Batched x50: a single instantiate+destroy is ~60 µs, where fixed harness
+  // overhead and cache-model variation across runner CPUs dominate; the loop
+  // puts the body in the ms range so the codec work is the signal.
+  bench("instantiate+destroy JPEGDecoder x50", () => {
+    for (let i = 0; i < 50; i++) {
+      const d = new codec.JPEGDecoder()
+      d.delete()
+    }
   })
 
-  bench("instantiate+destroy JPEGEncoder", () => {
-    const e = new codec.JPEGEncoder()
-    e.delete()
+  bench("instantiate+destroy JPEGEncoder x50", () => {
+    for (let i = 0; i < 50; i++) {
+      const e = new codec.JPEGEncoder()
+      e.delete()
+    }
   })
 
   bench("decode jpeg400jfif.jpg (600x800x8bit) — cold", () => {
diff --git a/packages/libjpeg-turbo-8bit/test/decode.test.js b/packages/libjpeg-turbo-8bit/test/decode.test.js
index 5212d90..315e483 100644
--- a/packages/libjpeg-turbo-8bit/test/decode.test.js
+++ b/packages/libjpeg-turbo-8bit/test/decode.test.js
@@ -1,13 +1,26 @@
 import { beforeAll, describe, expect, it } from "vitest"
-import { readFileSync } from "node:fs"
+import { existsSync, readFileSync } from "node:fs"
 import { fileURLToPath } from "node:url"
 import { dirname, resolve } from "node:path"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
 const fixturesDir = resolve(__dirname, "fixtures")
 
 const jpeg400 = readFileSync(resolve(fixturesDir, "jpeg/jpeg400jfif.jpg"))
 const jpeg400Raw = readFileSync(resolve(fixturesDir, "raw/jpeg400jfif.raw"))
+// Progressive (SOF2) variant of the same image — a distinct libjpeg decode
+// module (jdcoefct/progressive refinement) not exercised by the baseline
+// fixture. Golden verified bit-identical against Pillow's independently
+// built libjpeg on 2026-07-07; asm.js and wasm variants agree byte-exact.
+const jpegProgressive = readFileSync(resolve(fixturesDir, "jpeg/jpeg400jfif-new.jpg"))
+const jpegProgressiveRaw = readFileSync(resolve(fixturesDir, "raw/jpeg400jfif-new.raw"))
+// Color 4:2:0 YCbCr baseline JPEG encoded from the US1 RGB ultrasound frame
+// (tools/fixture-verification/gen/generate-fixtures.mjs). Decoded golden
+// verified bit-identical against DCMTK dcmdjpeg (0 of 921600 bytes differ,
+// 2026-07-07) — pins the YCbCr->RGB conversion + chroma upsampling path.
+const jpegColor = readFileSync(resolve(fixturesDir, "jpeg/US1-color-420.jpg"))
+const jpegColorRaw = readFileSync(resolve(fixturesDir, "raw/US1-color-420.raw"))
 
 async function loadModule(modulePath) {
   const mod = await import(modulePath)
@@ -16,18 +29,25 @@ async function loadModule(modulePath) {
 }
 
 const buildVariants = [
-  { name: "asm.js (libjpegturbojs)", path: "../dist/libjpegturbojs.js" },
-  { name: "wasm (libjpegturbowasm)", path: "../dist/libjpegturbowasm.js" },
+  { name: "asm.js (libjpegturbojs)", path: "../dist/libjpegturbojs.js", dist: "libjpegturbojs.js" },
+  { name: "wasm (libjpegturbowasm)", path: "../dist/libjpegturbowasm.js", dist: "libjpegturbowasm.js" },
 ]
 
-describe.each(buildVariants)("libjpeg-turbo-8bit decode — $name", ({ path }) => {
+describe.each(buildVariants)("libjpeg-turbo-8bit decode — $name", ({ path, dist }) => {
+  const isBuilt = existsSync(resolve(distDir, dist))
   let codec
 
   beforeAll(async () => {
-    codec = await loadModule(path)
+    if (isBuilt) codec = await loadModule(path)
   })
 
-  it("decodes the jpeg400 grayscale fixture", () => {
+  // In CI a missing dist means the build/artifact pipeline broke; fail loudly
+  // instead of letting every skipIf() below silently skip the suite.
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, `${dist} missing — build artifact was not replayed`).toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("decodes the jpeg400 grayscale fixture to bytes matching the RAW reference", () => {
     const decoder = new codec.JPEGDecoder()
     const encodedBuffer = decoder.getEncodedBuffer(jpeg400.length)
     encodedBuffer.set(jpeg400)
@@ -41,13 +61,48 @@ describe.each(buildVariants)("libjpeg-turbo-8bit decode — $name", ({ path }) =
     expect(frameInfo.componentCount).toBe(1)
 
     const decoded = decoder.getDecodedBuffer()
-    expect(decoded.length).toBe(600 * 800)
     expect(decoded.length).toBe(jpeg400Raw.length)
+    // Baseline JPEG decoding is deterministic: the decoded pixels must match
+    // the RAW reference exactly (identical across asm.js and wasm variants).
+    expect(Buffer.from(decoded).equals(jpeg400Raw)).toBe(true)
+
+    decoder.delete()
+  })
+
+  it.skipIf(!isBuilt)("decodes a progressive (SOF2) JPEG to bytes matching the RAW reference", () => {
+    const decoder = new codec.JPEGDecoder()
+    decoder.getEncodedBuffer(jpegProgressive.length).set(jpegProgressive)
+    decoder.decode()
+
+    const frameInfo = decoder.getFrameInfo()
+    expect(frameInfo.width).toBe(600)
+    expect(frameInfo.height).toBe(800)
+    expect(frameInfo.componentCount).toBe(1)
+
+    const decoded = decoder.getDecodedBuffer()
+    expect(Buffer.from(decoded).equals(jpegProgressiveRaw)).toBe(true)
+
+    decoder.delete()
+  })
+
+  it.skipIf(!isBuilt)("decodes a color 4:2:0 YCbCr JPEG to interleaved RGB matching the DCMTK-verified reference", () => {
+    const decoder = new codec.JPEGDecoder()
+    decoder.getEncodedBuffer(jpegColor.length).set(jpegColor)
+    decoder.decode()
+
+    const frameInfo = decoder.getFrameInfo()
+    expect(frameInfo.width).toBe(640)
+    expect(frameInfo.height).toBe(480)
+    expect(frameInfo.componentCount).toBe(3)
+
+    const decoded = decoder.getDecodedBuffer()
+    expect(decoded.length).toBe(640 * 480 * 3)
+    expect(Buffer.from(decoded).equals(jpegColorRaw)).toBe(true)
 
     decoder.delete()
   })
 
-  it("throws or marks error on truncated input", () => {
+  it.skipIf(!isBuilt)("throws or marks error on truncated input", () => {
     const truncated = jpeg400.subarray(0, Math.floor(jpeg400.length / 2))
     const decoder = new codec.JPEGDecoder()
     const encodedBuffer = decoder.getEncodedBuffer(truncated.length)
@@ -61,14 +116,15 @@ describe.each(buildVariants)("libjpeg-turbo-8bit decode — $name", ({ path }) =
 
 describe.each(buildVariants)(
   "libjpeg-turbo-8bit encode + round-trip — $name",
-  ({ path }) => {
+  ({ path, dist }) => {
+    const isBuilt = existsSync(resolve(distDir, dist))
     let codec
 
     beforeAll(async () => {
-      codec = await loadModule(path)
+      if (isBuilt) codec = await loadModule(path)
     })
 
-    it("encodes raw → JPEG and decodes back to the same dimensions", () => {
+    it.skipIf(!isBuilt)("encodes raw → JPEG and decodes back to the same dimensions", () => {
       const frameInfo = {
         width: 600,
         height: 800,
@@ -82,8 +138,10 @@ describe.each(buildVariants)(
 
       encoder.encode()
       const encoded = encoder.getEncodedBuffer()
-      expect(encoded.length).toBeGreaterThan(0)
-      expect(encoded.length).toBeLessThan(jpeg400Raw.length)
+      // Measured 63975 bytes at the default quality (95) on 2026-07-07;
+      // ceiling = compression regression, floor = silent truncation.
+      expect(encoded.length).toBeGreaterThan(63975 * 0.5)
+      expect(encoded.length).toBeLessThan(63975 * 1.10)
 
       const decoder = new codec.JPEGDecoder()
       const inBuffer = decoder.getEncodedBuffer(encoded.length)
@@ -99,6 +157,30 @@ describe.each(buildVariants)(
       const roundTripDecoded = decoder.getDecodedBuffer()
       expect(roundTripDecoded.length).toBe(jpeg400Raw.length)
 
+      // Baseline JPEG is lossy, so byte equality is not expected — but the
+      // error must stay small. Measured on this fixture: maxAbsDiff 6,
+      // meanAbsDiff 0.26. Bound it so a broken DCT/quantization path (which
+      // produces structurally wrong pixels, not slightly-off ones) fails.
+      let maxAbsDiff = 0
+      let totalAbsDiff = 0
+      for (let i = 0; i < jpeg400Raw.length; i++) {
+        const diff = Math.abs(roundTripDecoded[i] - jpeg400Raw[i])
+        if (diff > maxAbsDiff) maxAbsDiff = diff
+        totalAbsDiff += diff
+      }
+      expect(maxAbsDiff).toBeLessThanOrEqual(10)
+      expect(totalAbsDiff / jpeg400Raw.length).toBeLessThanOrEqual(1)
+
+      // PSNR floor: measured 53.6 dB at default quality on 2026-07-07. A
+      // broken DCT/quantization path lands tens of dB below this.
+      let sumSq = 0
+      for (let i = 0; i < jpeg400Raw.length; i++) {
+        const diff = roundTripDecoded[i] - jpeg400Raw[i]
+        sumSq += diff * diff
+      }
+      const psnr = 10 * Math.log10((255 * 255) / (sumSq / jpeg400Raw.length))
+      expect(psnr).toBeGreaterThan(48)
+
       decoder.delete()
       encoder.delete()
     })
diff --git a/packages/libjpeg-turbo-8bit/test/fixtures/jpeg/US1-color-420.jpg b/packages/libjpeg-turbo-8bit/test/fixtures/jpeg/US1-color-420.jpg
new file mode 100644
index 0000000..ea90210
Binary files /dev/null and b/packages/libjpeg-turbo-8bit/test/fixtures/jpeg/US1-color-420.jpg differ
diff --git a/packages/libjpeg-turbo-8bit/test/fixtures/raw/US1-color-420.raw b/packages/libjpeg-turbo-8bit/test/fixtures/raw/US1-color-420.raw
new file mode 100644
index 0000000..56584d3
Binary files /dev/null and b/packages/libjpeg-turbo-8bit/test/fixtures/raw/US1-color-420.raw differ
diff --git a/packages/libjpeg-turbo-8bit/test/fixtures/raw/jpeg400jfif-new.raw b/packages/libjpeg-turbo-8bit/test/fixtures/raw/jpeg400jfif-new.raw
new file mode 100644
index 0000000..6c262a9
Binary files /dev/null and b/packages/libjpeg-turbo-8bit/test/fixtures/raw/jpeg400jfif-new.raw differ
diff --git a/packages/libjpeg-turbo-8bit/test/heap-stability.test.js b/packages/libjpeg-turbo-8bit/test/heap-stability.test.js
new file mode 100644
index 0000000..d370309
--- /dev/null
+++ b/packages/libjpeg-turbo-8bit/test/heap-stability.test.js
@@ -0,0 +1,85 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "libjpegturbowasm.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+// Emscripten heaps grow but never shrink, so a native-side leak shows up as
+// monotonic HEAP8 growth across repeated use — invisible to single-decode
+// tests, an OOM after thousands of frames in a viewer. This repo has a
+// history of exactly that class of bug (error-path instance leaks, encoder
+// handle leaks).
+//
+// Loop sizing matters: the arena starts at 50 MiB (INITIAL_MEMORY) with
+// ALLOW_MEMORY_GROWTH, so a leak only becomes visible once the leaked
+// instances exceed the arena's free slack; 100+ instance-sized leaks
+// comfortably exceed it (see the charls twin of this file for the
+// calibration measurements).
+describe("libjpeg-turbo-8bit wasm heap stability", { timeout: 120000 }, () => {
+  let codec
+  const encoded = readFileSync(resolve(fixturesDir, "jpeg/jpeg400jfif.jpg"))
+  const raw = readFileSync(resolve(fixturesDir, "raw/jpeg400jfif.raw"))
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/libjpegturbowasm.js")
+  })
+
+  it.skipIf(!isBuilt)("repeated decode/delete cycles do not grow the heap", () => {
+    const decodeOnce = () => {
+      const decoder = new codec.JPEGDecoder()
+      decoder.getEncodedBuffer(encoded.length).set(encoded)
+      decoder.decode()
+      decoder.delete()
+    }
+    for (let i = 0; i < 10; i++) decodeOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 100; i++) decodeOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+
+  it.skipIf(!isBuilt)("repeated encode/delete cycles do not grow the heap", () => {
+    const encodeOnce = () => {
+      const encoder = new codec.JPEGEncoder()
+      encoder.getDecodedBuffer({ width: 600, height: 800, bitsPerSample: 8, componentCount: 1, isSigned: false }).set(raw)
+      encoder.encode()
+      encoder.delete()
+    }
+    for (let i = 0; i < 10; i++) encodeOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 60; i++) encodeOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+
+  it.skipIf(!isBuilt)("repeated failing decodes do not grow the heap", () => {
+    // Garbage (not truncated-after-valid-header) input: fails fast at
+    // header parse instead of spending seconds in sample recovery, so the
+    // loop can be large enough for a leak to exceed the arena slack.
+    const garbage = new Uint8Array(64)
+    for (let i = 0; i < garbage.length; i++) garbage[i] = (i * 37 + 11) % 256
+    const failOnce = () => {
+      const decoder = new codec.JPEGDecoder()
+      decoder.getEncodedBuffer(garbage.length).set(garbage)
+      try {
+        decoder.decode()
+      } catch {
+        // expected for malformed input
+      }
+      decoder.delete()
+    }
+    for (let i = 0; i < 10; i++) failOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 100; i++) failOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+})
diff --git a/packages/libjpeg-turbo-8bit/vitest.config.mjs b/packages/libjpeg-turbo-8bit/vitest.config.mjs
index 0250bc5..541f079 100644
--- a/packages/libjpeg-turbo-8bit/vitest.config.mjs
+++ b/packages/libjpeg-turbo-8bit/vitest.config.mjs
@@ -4,6 +4,18 @@ import codspeedPlugin from "@codspeed/vitest-plugin"
 export default defineConfig({
   plugins: [codspeedPlugin()],
   test: {
+    // Under the CodSpeed simulation instrument the entire process runs ~60x
+    // slower under valgrind while vitest's hard-coded 60s worker-RPC timer
+    // counts real seconds, so large bench suites structurally hit "Timeout
+    // calling onTaskUpdate" AFTER their benches complete and upload. Ignore
+    // that exit-code noise in simulation only; walltime and test runs stay
+    // strict.
+    // (CODSPEED_ENV is set whenever the CodSpeed runner is active; the
+    // mode string is "instrumentation" on older runners and "simulation"
+    // on newer ones, so match anything except walltime.)
+    dangerouslyIgnoreUnhandledErrors:
+      process.env.CODSPEED_ENV !== undefined &&
+      process.env.CODSPEED_RUNNER_MODE !== "walltime",
     name: "libjpeg-turbo-8bit",
     include: ["test/**/*.test.js"],
     benchmark: {
diff --git a/packages/little-endian/bench/decode.bench.js b/packages/little-endian/bench/decode.bench.js
index c4b919f..7e25920 100644
--- a/packages/little-endian/bench/decode.bench.js
+++ b/packages/little-endian/bench/decode.bench.js
@@ -3,6 +3,12 @@ import decode from "../src/index.js"
 
 const SIZE_512x512 = 512 * 512
 
+// decode() only creates typed-array views (no per-pixel work), so a single
+// call is sub-microsecond and the measurement is dominated by fixed harness
+// overhead and cache-model variation across runner CPUs. Batch x100 so the
+// body is in the ms range and the decode path is the signal.
+const ITERS = 100
+
 function makeBuffer(byteLen) {
   const data = new Uint8Array(byteLen)
   for (let i = 0; i < byteLen; i++) data[i] = (i * 37) & 0xff
@@ -12,21 +18,29 @@ function makeBuffer(byteLen) {
 describe("little-endian decode", () => {
   const data16 = makeBuffer(SIZE_512x512 * 2)
 
-  bench("16-bit unsigned, 512x512", () => {
-    decode({ bitsAllocated: 16, pixelRepresentation: 0 }, data16)
+  bench("16-bit unsigned, 512x512 x100", () => {
+    for (let i = 0; i < ITERS; i++) {
+      decode({ bitsAllocated: 16, pixelRepresentation: 0 }, data16)
+    }
   })
 
-  bench("16-bit signed, 512x512", () => {
-    decode({ bitsAllocated: 16, pixelRepresentation: 1 }, data16)
+  bench("16-bit signed, 512x512 x100", () => {
+    for (let i = 0; i < ITERS; i++) {
+      decode({ bitsAllocated: 16, pixelRepresentation: 1 }, data16)
+    }
   })
 
   const data8 = makeBuffer(SIZE_512x512)
-  bench("8-bit passthrough, 512x512", () => {
-    decode({ bitsAllocated: 8 }, data8)
+  bench("8-bit passthrough, 512x512 x100", () => {
+    for (let i = 0; i < ITERS; i++) {
+      decode({ bitsAllocated: 8 }, data8)
+    }
   })
 
   const data32 = makeBuffer(SIZE_512x512 * 4)
-  bench("32-bit float, 512x512", () => {
-    decode({ bitsAllocated: 32 }, data32)
+  bench("32-bit float, 512x512 x100", () => {
+    for (let i = 0; i < ITERS; i++) {
+      decode({ bitsAllocated: 32 }, data32)
+    }
   })
 })
diff --git a/packages/little-endian/vitest.config.mjs b/packages/little-endian/vitest.config.mjs
index 5357d03..5037255 100644
--- a/packages/little-endian/vitest.config.mjs
+++ b/packages/little-endian/vitest.config.mjs
@@ -4,6 +4,18 @@ import codspeedPlugin from "@codspeed/vitest-plugin"
 export default defineConfig({
   plugins: [codspeedPlugin()],
   test: {
+    // Under the CodSpeed simulation instrument the entire process runs ~60x
+    // slower under valgrind while vitest's hard-coded 60s worker-RPC timer
+    // counts real seconds, so large bench suites structurally hit "Timeout
+    // calling onTaskUpdate" AFTER their benches complete and upload. Ignore
+    // that exit-code noise in simulation only; walltime and test runs stay
+    // strict.
+    // (CODSPEED_ENV is set whenever the CodSpeed runner is active; the
+    // mode string is "instrumentation" on older runners and "simulation"
+    // on newer ones, so match anything except walltime.)
+    dangerouslyIgnoreUnhandledErrors:
+      process.env.CODSPEED_ENV !== undefined &&
+      process.env.CODSPEED_RUNNER_MODE !== "walltime",
     name: "little-endian",
     include: ["test/**/*.test.js"],
     benchmark: {
diff --git a/packages/openjpeg/bench/decode.bench.js b/packages/openjpeg/bench/decode.bench.js
index 101168d..e2bda70 100644
--- a/packages/openjpeg/bench/decode.bench.js
+++ b/packages/openjpeg/bench/decode.bench.js
@@ -56,7 +56,9 @@ let coldEnc
 let warmEnc
 if (!skip) {
   const factory = (await import(distPath)).default ?? (await import(distPath))
-  codec = await factory()
+  // Silence wasm stdout/stderr so vitest's console interception never runs
+  // inside a measured bench body (see openjphjs bench for details).
+  codec = await factory({ print: () => {}, printErr: () => {} })
 
   // Cold instances: one per fixture, constructed but never decoded.
   coldDecCT1 = new codec.J2KDecoder()
@@ -80,14 +82,21 @@ if (!skip) {
 }
 
 describe.skipIf(skip)("openjpeg J2K (wasm)", () => {
-  bench("instantiate+destroy J2KDecoder", () => {
-    const d = new codec.J2KDecoder()
-    d.delete()
+  // Batched x50: a single instantiate+destroy is ~60 µs, where fixed harness
+  // overhead and cache-model variation across runner CPUs dominate; the loop
+  // puts the body in the ms range so the codec work is the signal.
+  bench("instantiate+destroy J2KDecoder x50", () => {
+    for (let i = 0; i < 50; i++) {
+      const d = new codec.J2KDecoder()
+      d.delete()
+    }
   })
 
-  bench("instantiate+destroy J2KEncoder", () => {
-    const e = new codec.J2KEncoder()
-    e.delete()
+  bench("instantiate+destroy J2KEncoder x50", () => {
+    for (let i = 0; i < 50; i++) {
+      const e = new codec.J2KEncoder()
+      e.delete()
+    }
   })
 
   bench("decode CT1.j2k (.90 lossless 5-3, 512x512x16bit) — cold", () => {
diff --git a/packages/openjpeg/test/api.test.js b/packages/openjpeg/test/api.test.js
new file mode 100644
index 0000000..d77fc42
--- /dev/null
+++ b/packages/openjpeg/test/api.test.js
@@ -0,0 +1,196 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { createHash } from "node:crypto"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "openjpegwasm.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+const ct1 = () => readFileSync(resolve(fixturesDir, "j2k/CT1.j2k"))
+const ct1Raw = () => readFileSync(resolve(fixturesDir, "raw/CT1.RAW"))
+const lossy = () => readFileSync(resolve(fixturesDir, "j2k/CT-512x512-lossy.j2k"))
+
+// Exercises the embind surface beyond decode(): header introspection,
+// sub-resolution (progressive) decode, and encoder setters. Literals are
+// derived from CT1's known encode parameters, not blind snapshots: CT1 was
+// encoded with 5 decompositions, single layer, LRCP progression, 64x64
+// code blocks, grayscale.
+describe("openjpeg J2K API surface", () => {
+  let codec
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/openjpegwasm.js")
+  })
+
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, "openjpegwasm.js missing — build artifact was not replayed").toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("exposes coding parameters through the getters after decode()", () => {
+    const encoded = ct1()
+    const decoder = new codec.J2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decode()
+
+    expect(decoder.getNumDecompositions()).toBe(5)
+    expect(decoder.getIsReversible()).toBe(true)
+    expect(decoder.getProgressionOrder()).toBe(0) // LRCP
+    expect(decoder.getNumLayers()).toBe(1)
+    expect(decoder.getColorSpace()).toBe(2) // OPJ_CLRSPC_GRAY
+    expect(decoder.getBlockDimensions()).toEqual({ width: 64, height: 64 })
+    expect(decoder.getImageOffset()).toEqual({ x: 0, y: 0 })
+    expect(decoder.calculateSizeAtDecompositionLevel(0)).toEqual({ width: 512, height: 512 })
+    expect(decoder.calculateSizeAtDecompositionLevel(1)).toEqual({ width: 256, height: 256 })
+    expect(decoder.calculateSizeAtDecompositionLevel(2)).toEqual({ width: 128, height: 128 })
+
+    decoder.delete()
+  })
+
+  // KNOWN BUG (found 2026-07-07 while adding this suite): readHeader() does
+  // not populate frameInfo or the coding-parameter state — every getter
+  // returns zeros (and, for some fixtures, uninitialized values such as
+  // getNumDecompositions() === 4294965296). Consumers must call decode()
+  // before trusting any getter. When readHeader() is fixed to parse the
+  // header, this test starts passing and vitest will flag it — then convert
+  // it into a plain it().
+  it.fails.skipIf(!isBuilt)("readHeader() alone populates frameInfo (known broken)", () => {
+    const encoded = ct1()
+    const decoder = new codec.J2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.readHeader()
+    const frameInfo = decoder.getFrameInfo()
+    decoder.delete()
+    expect(frameInfo.width).toBe(512)
+  })
+
+  // KNOWN BUG: the .91 fixture uses the irreversible 9-7 wavelet, but
+  // getIsReversible() reports true after decoding it. Flips to failing
+  // (= fixed) when the wiring is corrected.
+  it.fails.skipIf(!isBuilt)("getIsReversible() is false for the lossy 9-7 stream (known broken)", () => {
+    const encoded = lossy()
+    const decoder = new codec.J2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decode()
+    const reversible = decoder.getIsReversible()
+    decoder.delete()
+    expect(reversible).toBe(false)
+  })
+
+  it.skipIf(!isBuilt)("decodeSubResolution() produces the level-1 and level-2 images", () => {
+    const encoded = ct1()
+    const decoder = new codec.J2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+
+    decoder.decodeSubResolution(1, 0)
+    const sub1 = Buffer.from(decoder.getDecodedBuffer())
+    expect(sub1.length).toBe(256 * 256 * 2)
+    // Regression pin. Cross-validated: openjphjs decodeSubResolution(1) on
+    // CT1.j2c produces the byte-identical buffer (the 5/3 LL band is
+    // mathematically shared between J2K and HTJ2K of the same source).
+    expect(createHash("sha256").update(sub1).digest("hex")).toBe(
+      "b6c934cad65758b2c90b5b7e2bea6ca2cd96574b547bb6720f1ca405e791abee"
+    )
+
+    decoder.decodeSubResolution(2, 0)
+    const sub2 = Buffer.from(decoder.getDecodedBuffer())
+    expect(sub2.length).toBe(128 * 128 * 2)
+
+    decoder.delete()
+  })
+
+  it.skipIf(!isBuilt)("setProgressionOrder() round-trips through the encoded stream", () => {
+    const raw = ct1Raw()
+    const frameInfo = { width: 512, height: 512, bitsPerSample: 16, componentCount: 1, isSigned: true }
+    const encoder = new codec.J2KEncoder()
+    encoder.getDecodedBuffer(frameInfo).set(raw)
+    encoder.setProgressionOrder(2) // RPCL
+    encoder.encode()
+    const encoded = Buffer.from(encoder.getEncodedBuffer())
+    encoder.delete()
+
+    const decoder = new codec.J2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decode()
+    expect(decoder.getProgressionOrder()).toBe(2)
+    // structural change only: pixels still lossless
+    expect(Buffer.from(decoder.getDecodedBuffer()).equals(raw)).toBe(true)
+    decoder.delete()
+  })
+
+  // KNOWN DEAD SETTERS (found 2026-07-07): the encoder stores but never
+  // applies blockDimensions_, tileSize_, tileOffset_, precincts_ and
+  // downSample_ — encode() never copies them into opj_cparameters
+  // (no cblockw_init / cp_tdx / prcw_init wiring). Only imageOffset,
+  // progressionOrder, decompositions, quality/ratios are live. This
+  // sentinel flips when setBlockDimensions gets wired; wire and test the
+  // other four with it.
+  it.fails.skipIf(!isBuilt)("setBlockDimensions() round-trips through the encoded stream (known dead setter)", () => {
+    const raw = ct1Raw()
+    const frameInfo = { width: 512, height: 512, bitsPerSample: 16, componentCount: 1, isSigned: true }
+    const encoder = new codec.J2KEncoder()
+    encoder.getDecodedBuffer(frameInfo).set(raw)
+    encoder.setBlockDimensions({ width: 32, height: 32 })
+    encoder.encode()
+    const encoded = Buffer.from(encoder.getEncodedBuffer())
+    encoder.delete()
+
+    const decoder = new codec.J2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decode()
+    expect(decoder.getBlockDimensions()).toEqual({ width: 32, height: 32 })
+    expect(Buffer.from(decoder.getDecodedBuffer()).equals(raw)).toBe(true)
+    decoder.delete()
+  })
+
+  it.skipIf(!isBuilt)("setCompressionRatio() produces a lossy stream with bounded distortion", () => {
+    const raw = ct1Raw()
+    const frameInfo = { width: 512, height: 512, bitsPerSample: 16, componentCount: 1, isSigned: true }
+
+    const losslessEncoder = new codec.J2KEncoder()
+    losslessEncoder.getDecodedBuffer(frameInfo).set(raw)
+    losslessEncoder.encode()
+    const losslessSize = losslessEncoder.getEncodedBuffer().length
+    losslessEncoder.delete()
+
+    const encoder = new codec.J2KEncoder()
+    encoder.getDecodedBuffer(frameInfo).set(raw)
+    encoder.setQuality(false, 1) // lossy (irreversible 9-7), 1 layer
+    encoder.setCompressionRatio(0, 10) // layer 0 at 10:1
+    encoder.encode()
+    const encoded = Buffer.from(encoder.getEncodedBuffer())
+    encoder.delete()
+
+    expect(encoded.length).toBeGreaterThan(0)
+    expect(encoded.length).toBeLessThan(losslessSize)
+
+    const decoder = new codec.J2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decode()
+    const out = Buffer.from(decoder.getDecodedBuffer())
+    decoder.delete()
+
+    // lossy: not byte-equal, but tightly bounded distortion (PSNR floor)
+    expect(out.equals(raw)).toBe(false)
+    const a = new Int16Array(raw.buffer, raw.byteOffset, raw.length / 2)
+    const b = new Int16Array(out.buffer, out.byteOffset, out.length / 2)
+    let sumSq = 0
+    for (let i = 0; i < a.length; i++) {
+      const d = a[i] - b[i]
+      sumSq += d * d
+    }
+    const mse = sumSq / a.length
+    const psnr = 10 * Math.log10((65535 * 65535) / mse)
+    // measured ~... generous floor: a broken quantization path lands far below
+    expect(psnr).toBeGreaterThan(50)
+  })
+})
diff --git a/packages/openjpeg/test/corpus.test.js b/packages/openjpeg/test/corpus.test.js
new file mode 100644
index 0000000..5dee069
--- /dev/null
+++ b/packages/openjpeg/test/corpus.test.js
@@ -0,0 +1,89 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "openjpegwasm.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+// Every shipped .j2k fixture with a committed RAW reference, previously
+// unused by any test. Verified byte-exact on activation (2026-07-07); the
+// RAWs are the references these lossless codestreams were produced from.
+// Together they pin the decoder across bit depths (8/10/12/15/16),
+// signedness, dimensions, and — for US1/VL* — 3-component color, which no
+// other openjpeg test touches. Variant agreement (asm.js/wasm/decode-only)
+// is covered for CT1/CT2 in decode.test.js; this corpus runs on the wasm
+// variant to keep runtime sane.
+const corpus = [
+  { file: "MG1.j2k", width: 3064, height: 4664, bps: 12, comp: 1, signed: false },
+  { file: "MR1.j2k", width: 512, height: 512, bps: 16, comp: 1, signed: true },
+  { file: "MR2.j2k", width: 1024, height: 1024, bps: 12, comp: 1, signed: false },
+  { file: "MR3.j2k", width: 512, height: 512, bps: 16, comp: 1, signed: true },
+  { file: "MR4.j2k", width: 512, height: 512, bps: 12, comp: 1, signed: false },
+  { file: "NM1.j2k", width: 256, height: 1024, bps: 16, comp: 1, signed: true },
+  { file: "RG1.j2k", width: 1841, height: 1955, bps: 15, comp: 1, signed: false },
+  { file: "RG2.j2k", width: 1760, height: 2140, bps: 10, comp: 1, signed: false },
+  { file: "RG3.j2k", width: 1760, height: 1760, bps: 10, comp: 1, signed: false },
+  { file: "SC1.j2k", width: 2048, height: 2487, bps: 12, comp: 1, signed: false },
+  { file: "XA1.j2k", width: 1024, height: 1024, bps: 10, comp: 1, signed: false },
+  { file: "US1.j2k", width: 640, height: 480, bps: 8, comp: 3, signed: false },
+  { file: "VL1.j2k", width: 756, height: 486, bps: 8, comp: 3, signed: false },
+  { file: "VL4.j2k", width: 2226, height: 1868, bps: 8, comp: 3, signed: false },
+  { file: "VL6.j2k", width: 756, height: 486, bps: 8, comp: 3, signed: false },
+]
+
+describe("openjpeg J2K decode corpus (bit depths, signedness, color)", () => {
+  let codec
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/openjpegwasm.js")
+  })
+
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, "openjpegwasm.js missing — build artifact was not replayed").toBe(true)
+  })
+
+  it.skipIf(!isBuilt).each(corpus)(
+    "decodes $file ($width x $height, $bps-bit, $comp comp) byte-exact vs RAW",
+    ({ file, width, height, bps, comp, signed }) => {
+      const encoded = readFileSync(resolve(fixturesDir, "j2k", file))
+      const raw = readFileSync(resolve(fixturesDir, "raw", file.replace(".j2k", ".RAW")))
+
+      const decoder = new codec.J2KDecoder()
+      decoder.getEncodedBuffer(encoded.length).set(encoded)
+      decoder.decode()
+
+      const frameInfo = decoder.getFrameInfo()
+      expect(frameInfo.width).toBe(width)
+      expect(frameInfo.height).toBe(height)
+      expect(frameInfo.bitsPerSample).toBe(bps)
+      expect(frameInfo.componentCount).toBe(comp)
+      expect(frameInfo.isSigned).toBe(signed)
+
+      const decoded = decoder.getDecodedBuffer()
+      expect(decoded.length).toBe(raw.length)
+      expect(Buffer.from(decoded).equals(raw)).toBe(true)
+
+      decoder.delete()
+    }
+  )
+
+  it.skipIf(!isBuilt)("decodes the 0-decomposition CT1 variant to the same pixels as CT1", () => {
+    const encoded = readFileSync(resolve(fixturesDir, "j2k/CT1-0decomp.j2k"))
+    const raw = readFileSync(resolve(fixturesDir, "raw/CT1.RAW"))
+    const decoder = new codec.J2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decode()
+    expect(Buffer.from(decoder.getDecodedBuffer()).equals(raw)).toBe(true)
+    decoder.delete()
+  })
+})
diff --git a/packages/openjpeg/test/decode.test.js b/packages/openjpeg/test/decode.test.js
index 220ff0d..80a4af8 100644
--- a/packages/openjpeg/test/decode.test.js
+++ b/packages/openjpeg/test/decode.test.js
@@ -13,8 +13,12 @@ const ct2Encoded = readFileSync(resolve(fixturesDir, "j2k/CT2.j2k"))
 const ct2Raw = readFileSync(resolve(fixturesDir, "raw/CT2.RAW"))
 // CT-512x512-lossy.j2k is a real .91 (JPEG 2000 Lossy) payload extracted from
 // a Cornerstone3D test DICOM. Uses an irreversible 9-7 wavelet, so byte
-// equality with any RAW is not expected.
+// equality with the original source pixels is not expected — but decoding is
+// deterministic, so we pin the decoder's own output as a regression golden
+// (CT-512x512-lossy.raw, generated by this codec and identical across the
+// asm.js/wasm/decode-only variants).
 const ctLossy = readFileSync(resolve(fixturesDir, "j2k/CT-512x512-lossy.j2k"))
+const ctLossyRaw = readFileSync(resolve(fixturesDir, "raw/CT-512x512-lossy.raw"))
 
 async function loadModule(modulePath) {
   const mod = await import(modulePath)
@@ -36,6 +40,12 @@ describe.each(buildVariants)("openjpeg J2K decode — $name", ({ path, dist }) =
     if (isBuilt) codec = await loadModule(path)
   })
 
+  // In CI a missing dist means the build/artifact pipeline broke; fail loudly
+  // instead of letting every skipIf() below silently skip the suite.
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, `${dist} missing — build artifact was not replayed`).toBe(true)
+  })
+
   it.skipIf(!isBuilt)(
     "decodes CT1.j2k to a 512x512 16-bit monochrome frame",
     () => {
@@ -69,7 +79,7 @@ describe.each(buildVariants)("openjpeg J2K decode — $name", ({ path, dist }) =
   })
 
   it.skipIf(!isBuilt)(
-    "decodes a lossy 9-7 J2K (transfer syntax .91) to a 512x512 16-bit frame",
+    "decodes a lossy 9-7 J2K (transfer syntax .91) matching the pinned golden output",
     () => {
       const decoder = new codec.J2KDecoder()
       decoder.getEncodedBuffer(ctLossy.length).set(ctLossy)
@@ -82,12 +92,42 @@ describe.each(buildVariants)("openjpeg J2K decode — $name", ({ path, dist }) =
       expect(frameInfo.componentCount).toBe(1)
 
       const decoded = decoder.getDecodedBuffer()
-      expect(decoded.length).toBe(512 * 512 * 2)
+      expect(decoded.length).toBe(ctLossyRaw.length)
+      expect(Buffer.from(decoded).equals(ctLossyRaw)).toBe(true)
       decoder.delete()
     }
   )
 })
 
+describe.each(buildVariants)("openjpeg J2K decode robustness — $name", ({ path, dist }) => {
+  const isBuilt = existsSync(resolve(distDir, dist))
+  let codec
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule(path)
+  })
+
+  it.skipIf(!isBuilt)("does not crash the process on a malformed/garbage buffer", () => {
+    const decoder = new codec.J2KDecoder()
+    const garbage = new Uint8Array(64)
+    for (let i = 0; i < garbage.length; i++) garbage[i] = (i * 37 + 11) % 256
+    decoder.getEncodedBuffer(garbage.length).set(garbage)
+
+    // Malformed input must either throw or return without corrupting the
+    // process (e.g. via an out-of-bounds heap write). Reaching this
+    // expectation at all is the meaningful assertion here.
+    expect(() => {
+      try {
+        decoder.decode()
+      } catch (e) {
+        // throwing is an acceptable, expected outcome for malformed input
+      }
+    }).not.toThrow()
+
+    decoder.delete()
+  })
+})
+
 const encoderVariants = buildVariants.filter((v) => !v.name.includes("decode-only"))
 
 describe.each(encoderVariants)(
@@ -114,7 +154,10 @@ describe.each(encoderVariants)(
         encoder.getDecodedBuffer(frameInfo).set(ct1Raw)
         encoder.encode()
         const encoded = encoder.getEncodedBuffer()
-        expect(encoded.length).toBeGreaterThan(0)
+        // Measured 174404 bytes on 2026-07-07 (emsdk 3.1.74); ceiling =
+        // compression regression, floor = silent truncation.
+        expect(encoded.length).toBeGreaterThan(174404 * 0.5)
+        expect(encoded.length).toBeLessThan(174404 * 1.10)
 
         const decoder = new codec.J2KDecoder()
         decoder.getEncodedBuffer(encoded.length).set(encoded)
diff --git a/packages/openjpeg/test/fixtures/raw/CT-512x512-lossy.raw b/packages/openjpeg/test/fixtures/raw/CT-512x512-lossy.raw
new file mode 100644
index 0000000..5fd199d
Binary files /dev/null and b/packages/openjpeg/test/fixtures/raw/CT-512x512-lossy.raw differ
diff --git a/packages/openjpeg/test/heap-stability.test.js b/packages/openjpeg/test/heap-stability.test.js
new file mode 100644
index 0000000..7f3b6c2
--- /dev/null
+++ b/packages/openjpeg/test/heap-stability.test.js
@@ -0,0 +1,71 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "openjpegwasm.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+// Emscripten heaps grow but never shrink, so a native-side leak shows up as
+// monotonic HEAP8 growth across repeated use — invisible to single-decode
+// tests, an OOM after thousands of frames in a viewer. This repo has a
+// history of exactly that class of bug (error-path instance leaks, encoder
+// handle leaks).
+//
+// Loop sizing matters: the arena starts at 50 MiB (INITIAL_MEMORY) with
+// ALLOW_MEMORY_GROWTH, so a leak only becomes visible once the leaked
+// instances exceed the arena's free slack; 100+ instance-sized leaks
+// comfortably exceed it (see the charls twin of this file for the
+// calibration measurements).
+describe("openjpeg wasm heap stability", { timeout: 120000 }, () => {
+  let codec
+  const encoded = readFileSync(resolve(fixturesDir, "j2k/CT1.j2k"))
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/openjpegwasm.js")
+  })
+
+  it.skipIf(!isBuilt)("repeated decode/delete cycles do not grow the heap", () => {
+    const decodeOnce = () => {
+      const decoder = new codec.J2KDecoder()
+      decoder.getEncodedBuffer(encoded.length).set(encoded)
+      decoder.decode()
+      decoder.delete()
+    }
+    for (let i = 0; i < 10; i++) decodeOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 100; i++) decodeOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+
+  it.skipIf(!isBuilt)("repeated failing decodes do not grow the heap", () => {
+    // Garbage (not truncated-after-valid-header) input: fails fast at
+    // header parse instead of spending seconds in sample recovery, so the
+    // loop can be large enough for a leak to exceed the arena slack.
+    const garbage = new Uint8Array(64)
+    for (let i = 0; i < garbage.length; i++) garbage[i] = (i * 37 + 11) % 256
+    const failOnce = () => {
+      const decoder = new codec.J2KDecoder()
+      decoder.getEncodedBuffer(garbage.length).set(garbage)
+      try {
+        decoder.decode()
+      } catch {
+        // expected for malformed input
+      }
+      decoder.delete()
+    }
+    for (let i = 0; i < 10; i++) failOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 100; i++) failOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+})
diff --git a/packages/openjpeg/vitest.config.mjs b/packages/openjpeg/vitest.config.mjs
index c253d42..2913463 100644
--- a/packages/openjpeg/vitest.config.mjs
+++ b/packages/openjpeg/vitest.config.mjs
@@ -4,6 +4,18 @@ import codspeedPlugin from "@codspeed/vitest-plugin"
 export default defineConfig({
   plugins: [codspeedPlugin()],
   test: {
+    // Under the CodSpeed simulation instrument the entire process runs ~60x
+    // slower under valgrind while vitest's hard-coded 60s worker-RPC timer
+    // counts real seconds, so large bench suites structurally hit "Timeout
+    // calling onTaskUpdate" AFTER their benches complete and upload. Ignore
+    // that exit-code noise in simulation only; walltime and test runs stay
+    // strict.
+    // (CODSPEED_ENV is set whenever the CodSpeed runner is active; the
+    // mode string is "instrumentation" on older runners and "simulation"
+    // on newer ones, so match anything except walltime.)
+    dangerouslyIgnoreUnhandledErrors:
+      process.env.CODSPEED_ENV !== undefined &&
+      process.env.CODSPEED_RUNNER_MODE !== "walltime",
     name: "openjpeg",
     include: ["test/**/*.test.js"],
     benchmark: {
diff --git a/packages/openjphjs/bench/decode.bench.js b/packages/openjphjs/bench/decode.bench.js
index 2c65bfb..c20471e 100644
--- a/packages/openjphjs/bench/decode.bench.js
+++ b/packages/openjphjs/bench/decode.bench.js
@@ -59,7 +59,11 @@ let coldEnc
 let warmEnc
 if (!skip) {
   const factory = (await import(distPath)).default ?? (await import(distPath))
-  codec = await factory()
+  // Silence wasm stdout/stderr: HTJ2KDecoder's constructor prints a banner,
+  // and vitest's console interception (stack-trace task attribution +
+  // source-map mapping) would otherwise run inside the measured bench body,
+  // swamping the microsecond-scale instantiate+destroy benches.
+  codec = await factory({ print: () => {}, printErr: () => {} })
 
   // Cold instances: one per fixture, constructed but never decoded.
   coldDecCT1 = new codec.HTJ2KDecoder()
@@ -82,14 +86,23 @@ if (!skip) {
 }
 
 describe.skipIf(skip)("openjphjs HTJ2K (wasm)", () => {
-  bench("instantiate+destroy HTJ2KDecoder", () => {
-    const d = new codec.HTJ2KDecoder()
-    d.delete()
+  // Lifecycle benches are batched: a single instantiate+destroy is ~60 µs,
+  // small enough that fixed harness overhead (bench-wrapper frames, task
+  // attribution) and the simulated cache model's CPU-to-CPU variation
+  // dominate the number. 50 iterations puts the body in the ms range where
+  // the codec work is the signal.
+  bench("instantiate+destroy HTJ2KDecoder x50", () => {
+    for (let i = 0; i < 50; i++) {
+      const d = new codec.HTJ2KDecoder()
+      d.delete()
+    }
   })
 
-  bench("instantiate+destroy HTJ2KEncoder", () => {
-    const e = new codec.HTJ2KEncoder()
-    e.delete()
+  bench("instantiate+destroy HTJ2KEncoder x50", () => {
+    for (let i = 0; i < 50; i++) {
+      const e = new codec.HTJ2KEncoder()
+      e.delete()
+    }
   })
 
   bench("decode CT1.j2c (.201 lossless, 512x512x16bit) — cold", () => {
diff --git a/packages/openjphjs/test/api.test.js b/packages/openjphjs/test/api.test.js
new file mode 100644
index 0000000..8330856
--- /dev/null
+++ b/packages/openjphjs/test/api.test.js
@@ -0,0 +1,71 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { createHash } from "node:crypto"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "openjphjs.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+// Header introspection and progressive (sub-resolution) decode — the
+// viewer's progressive-loading path, previously untested.
+describe("openjphjs HTJ2K API surface", () => {
+  let codec
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/openjphjs.js")
+  })
+
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, "openjphjs.js missing — build artifact was not replayed").toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("readHeader() populates frameInfo and decomposition info without decoding", () => {
+    const encoded = readFileSync(resolve(fixturesDir, "j2c/CT1.j2c"))
+    const decoder = new codec.HTJ2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.readHeader()
+
+    expect(decoder.getFrameInfo()).toEqual({
+      width: 512,
+      height: 512,
+      bitsPerSample: 16,
+      componentCount: 1,
+      isSigned: true,
+      isUsingColorTransform: false,
+    })
+    expect(decoder.getNumDecompositions()).toBe(5)
+    expect(decoder.calculateSizeAtDecompositionLevel(0)).toEqual({ width: 512, height: 512 })
+    expect(decoder.calculateSizeAtDecompositionLevel(1)).toEqual({ width: 256, height: 256 })
+    expect(decoder.calculateSizeAtDecompositionLevel(2)).toEqual({ width: 128, height: 128 })
+
+    decoder.delete()
+  })
+
+  it.skipIf(!isBuilt)("decodeSubResolution(1) produces the level-1 image", () => {
+    const encoded = readFileSync(resolve(fixturesDir, "j2c/CT1.j2c"))
+    const decoder = new codec.HTJ2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decodeSubResolution(1)
+    const sub1 = Buffer.from(decoder.getDecodedBuffer())
+    decoder.delete()
+
+    expect(sub1.length).toBe(256 * 256 * 2)
+    // Cross-codec validated pin: openjpeg's decodeSubResolution(1, 0) on
+    // CT1.j2k produces this byte-identical buffer — the reversible 5/3
+    // LL band at each resolution level is mathematically shared between
+    // J2K and HTJ2K encodes of the same source.
+    expect(createHash("sha256").update(sub1).digest("hex")).toBe(
+      "b6c934cad65758b2c90b5b7e2bea6ca2cd96574b547bb6720f1ca405e791abee"
+    )
+  })
+})
diff --git a/packages/openjphjs/test/corpus.test.js b/packages/openjphjs/test/corpus.test.js
new file mode 100644
index 0000000..ceacf27
--- /dev/null
+++ b/packages/openjphjs/test/corpus.test.js
@@ -0,0 +1,70 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { createHash } from "node:crypto"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const modulePath = "../dist/openjphjs.js"
+const isBuilt = existsSync(resolve(distDir, "openjphjs.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+// Every .j2c fixture in the repo, decoded and pinned by the SHA-256 of the
+// decoded pixel buffer. CT1/CT2 are additionally byte-verified against RAW
+// references in decode.test.js; the CT1/CT2 pixels are cross-validated
+// bit-for-bit against the charls and openjpeg codecs (all three decode the
+// same slices to identical bytes). The rest pin current decoder output as
+// regression goldens across a range of modalities, sizes and aspect ratios.
+// Hashes keep the repo small — a mismatch means the decoded pixels changed;
+// regenerate deliberately if a decoder upgrade legitimately changes output.
+const corpus = [
+  { file: "CT1.j2c", width: 512, height: 512, sha256: "1add6ede29758c6f0c68f01749ddc6c907e68a312be4eb9da8489e376e0bbd34" },
+  { file: "CT2.j2c", width: 512, height: 512, sha256: "ddaf7fb6a05bf7ac8b2b29e29cca3204e426179cce2888eeff3a270c1927d73d" },
+  { file: "MG1.j2c", width: 3064, height: 4774, sha256: "d4b670f1deccc165f72316858b746556acad6636ec0a381cd82b2bd23810a31c" },
+  { file: "MR1.j2c", width: 512, height: 512, sha256: "2541a628cb676972b37008a4fe6b5cce3df9866df62a77086bdffbe422064632" },
+  { file: "MR2.j2c", width: 1024, height: 1024, sha256: "7d1a676f3c012d0ca9d4fb9069c5dcca2b0bac014173dba48f0e32b9b49198b3" },
+  { file: "MR3.j2c", width: 512, height: 512, sha256: "9d32a2a63e3980d08130da4606abab010d6de943e9d504deb80ccb910fe5aa45" },
+  { file: "MR4.j2c", width: 512, height: 512, sha256: "9c7574cb23eef7f99481e94764d3efe4025db704be97cc18a944c0db2dfdb3d1" },
+  { file: "NM1.j2c", width: 256, height: 1024, sha256: "a6e9d32143339d3f5748b5520aa4e6c6ffb3550b6f71fdf17bdb2ebb44bc2611" },
+  { file: "RG1.j2c", width: 1841, height: 1955, sha256: "26721b2112d94887b0feae345f1b7c1c8148e1710eaf27283d8c3e650682d252" },
+  { file: "RG2.j2c", width: 1760, height: 2140, sha256: "9ed5d9818c250bb81ff9093a6c4d5c6032df281fce82b9a288de65c74348301e" },
+  { file: "RG3.j2c", width: 1760, height: 1760, sha256: "85480a0287e37795bc96799747a69af475f3bf0c35203fac1010fc6e100821a7" },
+  { file: "SC1.j2c", width: 2048, height: 2487, sha256: "1c8e43cef2a3b25b5304c3dd1732e64c2f44d05d342387ea8e15ce01ec793c32" },
+  { file: "XA1.j2c", width: 1024, height: 1024, sha256: "797b3375a2d1f94ccac04c657b5b5d90d9b4051f76508c867f2dea465d1a7f3b" },
+]
+
+describe("openjphjs HTJ2K decode corpus", () => {
+  let codec
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule(modulePath)
+  })
+
+  it.skipIf(!isBuilt).each(corpus)(
+    "decodes $file to pixels matching its pinned SHA-256",
+    ({ file, width, height, sha256 }) => {
+      const encoded = readFileSync(resolve(fixturesDir, "j2c", file))
+      const decoder = new codec.HTJ2KDecoder()
+      decoder.getEncodedBuffer(encoded.length).set(encoded)
+      decoder.decode()
+
+      const frameInfo = decoder.getFrameInfo()
+      expect(frameInfo.width).toBe(width)
+      expect(frameInfo.height).toBe(height)
+
+      const decoded = decoder.getDecodedBuffer()
+      const actual = createHash("sha256").update(decoded).digest("hex")
+      expect(actual).toBe(sha256)
+
+      decoder.delete()
+    }
+  )
+})
diff --git a/packages/openjphjs/test/decode.test.js b/packages/openjphjs/test/decode.test.js
index 8a9da43..f37f93d 100644
--- a/packages/openjphjs/test/decode.test.js
+++ b/packages/openjphjs/test/decode.test.js
@@ -28,6 +28,12 @@ describe("openjphjs HTJ2K decode", () => {
     if (isBuilt) codec = await loadModule(modulePath)
   })
 
+  // In CI a missing dist means the build/artifact pipeline broke; fail loudly
+  // instead of letting every skipIf() below silently skip the suite.
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, "openjphjs.js missing — build artifact was not replayed").toBe(true)
+  })
+
   it.skipIf(!isBuilt)(
     "decodes CT1.j2c to a 512x512 16-bit monochrome frame matching CT1.RAW",
     () => {
@@ -83,7 +89,10 @@ describe("openjphjs HTJ2K encode + round-trip", () => {
       encoder.getDecodedBuffer(frameInfo).set(ct1Raw)
       encoder.encode()
       const encoded = encoder.getEncodedBuffer()
-      expect(encoded.length).toBeGreaterThan(0)
+      // Measured 185183 bytes on 2026-07-07 (emsdk 3.1.74); ceiling =
+      // compression regression, floor = silent truncation.
+      expect(encoded.length).toBeGreaterThan(185183 * 0.5)
+      expect(encoded.length).toBeLessThan(185183 * 1.10)
 
       const decoder = new codec.HTJ2KDecoder()
       decoder.getEncodedBuffer(encoded.length).set(encoded)
diff --git a/packages/openjphjs/test/fixtures/j2c/CT2-gray12.j2c b/packages/openjphjs/test/fixtures/j2c/CT2-gray12.j2c
new file mode 100644
index 0000000..d8fa3f5
Binary files /dev/null and b/packages/openjphjs/test/fixtures/j2c/CT2-gray12.j2c differ
diff --git a/packages/openjphjs/test/fixtures/j2c/CT2-gray8.j2c b/packages/openjphjs/test/fixtures/j2c/CT2-gray8.j2c
new file mode 100644
index 0000000..e781bad
Binary files /dev/null and b/packages/openjphjs/test/fixtures/j2c/CT2-gray8.j2c differ
diff --git a/packages/openjphjs/test/fixtures/j2c/US1-color-ct.j2c b/packages/openjphjs/test/fixtures/j2c/US1-color-ct.j2c
new file mode 100644
index 0000000..3800212
Binary files /dev/null and b/packages/openjphjs/test/fixtures/j2c/US1-color-ct.j2c differ
diff --git a/packages/openjphjs/test/fixtures/j2c/US1-color-nct.j2c b/packages/openjphjs/test/fixtures/j2c/US1-color-nct.j2c
new file mode 100644
index 0000000..b1a422f
Binary files /dev/null and b/packages/openjphjs/test/fixtures/j2c/US1-color-nct.j2c differ
diff --git a/packages/openjphjs/test/heap-stability.test.js b/packages/openjphjs/test/heap-stability.test.js
new file mode 100644
index 0000000..0380324
--- /dev/null
+++ b/packages/openjphjs/test/heap-stability.test.js
@@ -0,0 +1,85 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "openjphjs.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+// Emscripten heaps grow but never shrink, so a native-side leak shows up as
+// monotonic HEAP8 growth across repeated use — invisible to single-decode
+// tests, an OOM after thousands of frames in a viewer. This repo has a
+// history of exactly that class of bug (error-path instance leaks, encoder
+// handle leaks).
+//
+// Loop sizing matters: the arena starts at 50 MiB (INITIAL_MEMORY) with
+// ALLOW_MEMORY_GROWTH, so a leak only becomes visible once the leaked
+// instances exceed the arena's free slack; 100+ instance-sized leaks
+// comfortably exceed it (see the charls twin of this file for the
+// calibration measurements).
+describe("openjphjs wasm heap stability", { timeout: 120000 }, () => {
+  let codec
+  const encoded = readFileSync(resolve(fixturesDir, "j2c/CT1.j2c"))
+  const raw = readFileSync(resolve(fixturesDir, "raw/CT1.RAW"))
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/openjphjs.js")
+  })
+
+  it.skipIf(!isBuilt)("repeated decode/delete cycles do not grow the heap", () => {
+    const decodeOnce = () => {
+      const decoder = new codec.HTJ2KDecoder()
+      decoder.getEncodedBuffer(encoded.length).set(encoded)
+      decoder.decode()
+      decoder.delete()
+    }
+    for (let i = 0; i < 10; i++) decodeOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 100; i++) decodeOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+
+  it.skipIf(!isBuilt)("repeated encode/delete cycles do not grow the heap", () => {
+    const encodeOnce = () => {
+      const encoder = new codec.HTJ2KEncoder()
+      encoder.getDecodedBuffer({ width: 512, height: 512, bitsPerSample: 16, componentCount: 1, isSigned: true, isUsingColorTransform: false }).set(raw)
+      encoder.encode()
+      encoder.delete()
+    }
+    for (let i = 0; i < 10; i++) encodeOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 60; i++) encodeOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+
+  it.skipIf(!isBuilt)("repeated failing decodes do not grow the heap", () => {
+    // Garbage (not truncated-after-valid-header) input: fails fast at
+    // header parse instead of spending seconds in sample recovery, so the
+    // loop can be large enough for a leak to exceed the arena slack.
+    const garbage = new Uint8Array(64)
+    for (let i = 0; i < garbage.length; i++) garbage[i] = (i * 37 + 11) % 256
+    const failOnce = () => {
+      const decoder = new codec.HTJ2KDecoder()
+      decoder.getEncodedBuffer(garbage.length).set(garbage)
+      try {
+        decoder.decode()
+      } catch {
+        // expected for malformed input
+      }
+      decoder.delete()
+    }
+    for (let i = 0; i < 10; i++) failOnce()
+    const settled = codec.HEAP8.length
+    for (let i = 0; i < 100; i++) failOnce()
+    expect(codec.HEAP8.length).toBe(settled)
+  })
+})
diff --git a/packages/openjphjs/test/matrix.test.js b/packages/openjphjs/test/matrix.test.js
new file mode 100644
index 0000000..1ade60c
--- /dev/null
+++ b/packages/openjphjs/test/matrix.test.js
@@ -0,0 +1,79 @@
+import { beforeAll, describe, expect, it } from "vitest"
+import { existsSync, readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+import { gray8FromCT2, gray12FromCT2 } from "../../../tools/fixture-verification/gen/derive.mjs"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distDir = resolve(__dirname, "../dist")
+const fixturesDir = resolve(__dirname, "fixtures")
+
+const isBuilt = existsSync(resolve(distDir, "openjphjs.js"))
+
+async function loadModule(path) {
+  const mod = await import(path)
+  const factory = mod.default ?? mod
+  return await factory()
+}
+
+const asBuffer = (ta) => Buffer.from(ta.buffer, ta.byteOffset, ta.byteLength)
+
+// Color and bit-depth coverage beyond the 16-bit CT corpus.
+//
+// Fixture provenance (tools/fixture-verification/gen/generate-fixtures.mjs):
+// all four are lossless HTJ2K encodes of committed sources (US1.RAW RGB
+// frame; deterministic CT2.RAW transforms from derive.mjs), so each test's
+// reference is re-derived from the source — a decoder regression on these
+// paths breaks byte equality.
+//
+// The color pair covers both isUsingColorTransform settings — the RCT path
+// was flagged "not been tested yet" in HTJ2KDecoder.hpp.
+describe("openjphjs HTJ2K decode matrix — color and bit depths", () => {
+  let codec
+  const us1 = readFileSync(resolve(__dirname, "../../openjpeg/test/fixtures/raw/US1.RAW"))
+  const ct2 = readFileSync(resolve(__dirname, "../../charls/test/fixtures/CT2.RAW"))
+
+  beforeAll(async () => {
+    if (isBuilt) codec = await loadModule("../dist/openjphjs.js")
+  })
+
+  it.runIf(process.env.CI)("dist is present in CI", () => {
+    expect(isBuilt, "openjphjs.js missing — build artifact was not replayed").toBe(true)
+  })
+
+  const decode = (file) => {
+    const encoded = readFileSync(resolve(fixturesDir, "j2c", file))
+    const decoder = new codec.HTJ2KDecoder()
+    decoder.getEncodedBuffer(encoded.length).set(encoded)
+    decoder.decode()
+    const frameInfo = decoder.getFrameInfo()
+    const out = Buffer.from(decoder.getDecodedBuffer())
+    decoder.delete()
+    return { frameInfo, out }
+  }
+
+  it.skipIf(!isBuilt)("decodes 3-component color losslessly (no color transform)", () => {
+    const { frameInfo, out } = decode("US1-color-nct.j2c")
+    expect(frameInfo.componentCount).toBe(3)
+    expect(frameInfo.bitsPerSample).toBe(8)
+    expect(out.equals(us1)).toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("decodes 3-component color losslessly (reversible color transform)", () => {
+    const { frameInfo, out } = decode("US1-color-ct.j2c")
+    expect(frameInfo.componentCount).toBe(3)
+    expect(out.equals(us1)).toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("decodes 8-bit grayscale losslessly", () => {
+    const { frameInfo, out } = decode("CT2-gray8.j2c")
+    expect(frameInfo.bitsPerSample).toBe(8)
+    expect(out.equals(asBuffer(gray8FromCT2(ct2)))).toBe(true)
+  })
+
+  it.skipIf(!isBuilt)("decodes 12-bit grayscale losslessly", () => {
+    const { frameInfo, out } = decode("CT2-gray12.j2c")
+    expect(frameInfo.bitsPerSample).toBe(12)
+    expect(out.equals(asBuffer(gray12FromCT2(ct2)))).toBe(true)
+  })
+})
diff --git a/packages/openjphjs/vitest.config.mjs b/packages/openjphjs/vitest.config.mjs
index 7262e3f..cc3d2b5 100644
--- a/packages/openjphjs/vitest.config.mjs
+++ b/packages/openjphjs/vitest.config.mjs
@@ -4,6 +4,18 @@ import codspeedPlugin from "@codspeed/vitest-plugin"
 export default defineConfig({
   plugins: [codspeedPlugin()],
   test: {
+    // Under the CodSpeed simulation instrument the entire process runs ~60x
+    // slower under valgrind while vitest's hard-coded 60s worker-RPC timer
+    // counts real seconds, so large bench suites structurally hit "Timeout
+    // calling onTaskUpdate" AFTER their benches complete and upload. Ignore
+    // that exit-code noise in simulation only; walltime and test runs stay
+    // strict.
+    // (CODSPEED_ENV is set whenever the CodSpeed runner is active; the
+    // mode string is "instrumentation" on older runners and "simulation"
+    // on newer ones, so match anything except walltime.)
+    dangerouslyIgnoreUnhandledErrors:
+      process.env.CODSPEED_ENV !== undefined &&
+      process.env.CODSPEED_RUNNER_MODE !== "walltime",
     name: "openjphjs",
     include: ["test/**/*.test.js"],
     benchmark: {
diff --git a/tools/browser-smoke/blank.html b/tools/browser-smoke/blank.html
new file mode 100644
index 0000000..45692a6
--- /dev/null
+++ b/tools/browser-smoke/blank.html
@@ -0,0 +1 @@
+<!doctype html><title>codec smoke</title>
diff --git a/tools/browser-smoke/run.js b/tools/browser-smoke/run.js
new file mode 100644
index 0000000..1a15175
--- /dev/null
+++ b/tools/browser-smoke/run.js
@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+// Browser smoke-decode: loads every wasm/asm.js build variant of every
+// codec in headless Chromium, decodes its reference fixture IN THE PAGE,
+// and compares the SHA-256 of the decoded pixels against the RAW reference.
+//
+// This is the coverage node tests cannot give: emscripten glue differences
+// that only manifest in browsers (wasm URL resolution/locateFile, fetch vs
+// filesystem loading, streaming-compile MIME fallbacks) — exactly what
+// changes across emsdk versions.
+//
+// Usage: node tools/browser-smoke/run.js
+// Requires: built dists, npx playwright install chromium (cached in CI).
+"use strict";
+
+const http = require("http");
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+const { chromium } = require("playwright-core");
+
+const repoRoot = path.resolve(__dirname, "../..");
+
+// [package, dist module, decoder class, encoded fixture, reference raw]
+// Every entry decodes CT1/jpeg400 and must hash-match its committed RAW.
+const VARIANTS = [
+  ["charls", "charlsjs.js", "JpegLSDecoder", "charls/test/fixtures/CT1.JLS", "charls/test/fixtures/CT1.RAW"],
+  ["charls", "charlswasm.js", "JpegLSDecoder", "charls/test/fixtures/CT1.JLS", "charls/test/fixtures/CT1.RAW"],
+  ["charls", "charlswasm_decode.js", "JpegLSDecoder", "charls/test/fixtures/CT1.JLS", "charls/test/fixtures/CT1.RAW"],
+  ["openjpeg", "openjpegjs.js", "J2KDecoder", "openjpeg/test/fixtures/j2k/CT1.j2k", "openjpeg/test/fixtures/raw/CT1.RAW"],
+  ["openjpeg", "openjpegwasm.js", "J2KDecoder", "openjpeg/test/fixtures/j2k/CT1.j2k", "openjpeg/test/fixtures/raw/CT1.RAW"],
+  ["openjpeg", "openjpegwasm_decode.js", "J2KDecoder", "openjpeg/test/fixtures/j2k/CT1.j2k", "openjpeg/test/fixtures/raw/CT1.RAW"],
+  ["openjphjs", "openjphjs.js", "HTJ2KDecoder", "openjphjs/test/fixtures/j2c/CT1.j2c", "openjphjs/test/fixtures/raw/CT1.RAW"],
+  ["libjpeg-turbo-8bit", "libjpegturbojs.js", "JPEGDecoder", "libjpeg-turbo-8bit/test/fixtures/jpeg/jpeg400jfif.jpg", "libjpeg-turbo-8bit/test/fixtures/raw/jpeg400jfif.raw"],
+  ["libjpeg-turbo-8bit", "libjpegturbowasm.js", "JPEGDecoder", "libjpeg-turbo-8bit/test/fixtures/jpeg/jpeg400jfif.jpg", "libjpeg-turbo-8bit/test/fixtures/raw/jpeg400jfif.raw"],
+];
+
+const MIME = {
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".wasm": "application/wasm", // correct MIME so streaming compilation runs
+  ".html": "text/html",
+  ".mem": "application/octet-stream",
+};
+
+function startServer() {
+  const server = http.createServer((req, res) => {
+    const urlPath = decodeURIComponent(new URL(req.url, "http://x").pathname);
+    const filePath = path.join(repoRoot, urlPath);
+    if (!filePath.startsWith(repoRoot) || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+      res.writeHead(404);
+      res.end("not found");
+      return;
+    }
+    res.writeHead(200, { "Content-Type": MIME[path.extname(filePath)] ?? "application/octet-stream" });
+    fs.createReadStream(filePath).pipe(res);
+  });
+  return new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve(server)));
+}
+
+// Runs inside the page. The dists are MODULARIZE=1 UMD outputs: loading via
+// a classic <script> tag defines a global factory (Module). The .wasm /
+// .js.mem sidecars resolve relative to the script URL.
+const PAGE_FN = async ({ distUrl, decoderClass, fixtureUrl }) => {
+  await new Promise((resolve, reject) => {
+    const s = document.createElement("script");
+    s.src = distUrl;
+    s.onload = resolve;
+    s.onerror = () => reject(new Error("script load failed: " + distUrl));
+    document.head.appendChild(s);
+  });
+  const factory = globalThis.Module ?? globalThis[Object.keys(globalThis).find((k) => /^(charls|OpenJPEG|openjph|libjpeg)/i.test(k))];
+  if (typeof factory !== "function") throw new Error("no module factory global found");
+  const codec = await factory();
+  delete globalThis.Module;
+
+  const fixture = new Uint8Array(await (await fetch(fixtureUrl)).arrayBuffer());
+  const decoder = new codec[decoderClass]();
+  decoder.getEncodedBuffer(fixture.length).set(fixture);
+  decoder.decode();
+  const decoded = decoder.getDecodedBuffer();
+  // hash the underlying bytes regardless of the view's element type
+  const bytes = new Uint8Array(decoded.buffer, decoded.byteOffset, decoded.byteLength).slice();
+  decoder.delete();
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+};
+
+(async () => {
+  const server = await startServer();
+  const port = server.address().port;
+  const browser = await chromium.launch();
+  const results = [];
+
+  for (const [pkg, dist, decoderClass, fixture, raw] of VARIANTS) {
+    const distFile = path.join(repoRoot, "packages", pkg, "dist", dist);
+    if (!fs.existsSync(distFile)) {
+      results.push([`${pkg}/${dist}`, "SKIP (dist not built)"]);
+      if (process.env.CI) results.push([`${pkg}/${dist}`, "FAIL: dist missing in CI"]);
+      continue;
+    }
+    const expected = crypto.createHash("sha256").update(fs.readFileSync(path.join(repoRoot, "packages", raw))).digest("hex");
+    const page = await browser.newPage();
+    const pageErrors = [];
+    page.on("pageerror", (e) => pageErrors.push(e.message));
+    try {
+      await page.goto(`http://127.0.0.1:${port}/tools/browser-smoke/blank.html`);
+      const actual = await page.evaluate(PAGE_FN, {
+        distUrl: `http://127.0.0.1:${port}/packages/${pkg}/dist/${dist}`,
+        decoderClass,
+        fixtureUrl: `http://127.0.0.1:${port}/packages/${fixture}`,
+      });
+      results.push([`${pkg}/${dist}`, actual === expected ? "PASS" : `FAIL: hash mismatch (${actual.slice(0, 12)}… != ${expected.slice(0, 12)}…)`]);
+    } catch (e) {
+      results.push([`${pkg}/${dist}`, `FAIL: ${e.message}${pageErrors.length ? " | page: " + pageErrors.join("; ") : ""}`]);
+    } finally {
+      await page.close();
+    }
+  }
+
+  await browser.close();
+  server.close();
+
+  const width = Math.max(...results.map(([n]) => n.length));
+  for (const [name, r] of results) console.log(name.padEnd(width + 2) + r);
+  const failures = results.filter(([, r]) => r.startsWith("FAIL")).length;
+  console.log(`\n${failures === 0 ? "PASS" : "FAIL"}: ${failures} browser decode failure(s)`);
+  process.exit(failures ? 1 : 0);
+})();
diff --git a/tools/dist-size/baseline.json b/tools/dist-size/baseline.json
new file mode 100644
index 0000000..b9fa184
--- /dev/null
+++ b/tools/dist-size/baseline.json
@@ -0,0 +1,116 @@
+{
+  "big-endian": {
+    "index.js": {
+      "raw": 1162,
+      "gzip": 609
+    }
+  },
+  "charls": {
+    "charlsjs.js": {
+      "raw": 537029,
+      "gzip": 108457
+    },
+    "charlsjs_decode.js": {
+      "raw": 340455,
+      "gzip": 77502
+    },
+    "charlswasm.js": {
+      "raw": 54139,
+      "gzip": 14501
+    },
+    "charlswasm.wasm": {
+      "raw": 247884,
+      "gzip": 66579
+    },
+    "charlswasm_decode.js": {
+      "raw": 54146,
+      "gzip": 14506
+    },
+    "charlswasm_decode.wasm": {
+      "raw": 145306,
+      "gzip": 46535
+    }
+  },
+  "libjpeg-turbo-12bit": {
+    "libjpegturbo12js.js": {
+      "raw": 2554703,
+      "gzip": 267545
+    },
+    "libjpegturbo12wasm.js": {
+      "raw": 113584,
+      "gzip": 29160
+    },
+    "libjpegturbo12wasm.wasm": {
+      "raw": 2238843,
+      "gzip": 760829
+    }
+  },
+  "libjpeg-turbo-8bit": {
+    "libjpegturbojs.js": {
+      "raw": 838040,
+      "gzip": 160427
+    },
+    "libjpegturbojs_decode.js": {
+      "raw": 418778,
+      "gzip": 118564
+    },
+    "libjpegturbowasm.js": {
+      "raw": 57327,
+      "gzip": 15530
+    },
+    "libjpegturbowasm.wasm": {
+      "raw": 448955,
+      "gzip": 96494
+    },
+    "libjpegturbowasm_decode.js": {
+      "raw": 56836,
+      "gzip": 15491
+    },
+    "libjpegturbowasm_decode.wasm": {
+      "raw": 180512,
+      "gzip": 70074
+    }
+  },
+  "little-endian": {
+    "index.js": {
+      "raw": 877,
+      "gzip": 477
+    }
+  },
+  "openjpeg": {
+    "openjpegjs.js": {
+      "raw": 754525,
+      "gzip": 199851
+    },
+    "openjpegjs_decode.js": {
+      "raw": 541739,
+      "gzip": 139864
+    },
+    "openjpegwasm.js": {
+      "raw": 56588,
+      "gzip": 15346
+    },
+    "openjpegwasm.wasm": {
+      "raw": 368511,
+      "gzip": 127471
+    },
+    "openjpegwasm_decode.js": {
+      "raw": 55920,
+      "gzip": 15236
+    },
+    "openjpegwasm_decode.wasm": {
+      "raw": 255857,
+      "gzip": 84237
+    }
+  },
+  "openjphjs": {
+    "openjphjs.js": {
+      "raw": 113863,
+      "gzip": 28916
+    },
+    "openjphjs.wasm": {
+      "raw": 2296745,
+      "gzip": 673433
+    }
+  }
+}
diff --git a/tools/dist-size/check.js b/tools/dist-size/check.js
new file mode 100644
index 0000000..d59f129
--- /dev/null
+++ b/tools/dist-size/check.js
@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+// Dist-size regression gate.
+//
+// Compares the built dist artifacts (packages/*/dist) against the committed
+// ground truth in baseline.json and fails when any shipped file grows past
+// tolerance, so a PR cannot regress binary size unintentionally.
+//
+// Usage:
+//   node tools/dist-size/check.js               # check against baseline.json
+//   node tools/dist-size/check.js --update      # rewrite baseline.json from
+//                                               # the current dists
+//   node tools/dist-size/check.js --artifacts <dir>
+//       read dists from <dir>/dist-<package>/ (the layout produced by
+//       `gh run download`) instead of packages/*/dist
+//
+// Tracked files: *.js, *.wasm, *.js.mem — the payloads users actually
+// download. Source maps and publish receipts are ignored.
+//
+// Both raw and gzip (level 9) sizes are tracked: gzip is what network
+// delivery actually costs, and raw is what memory/parse time costs.
+//
+// Tolerance: a file may grow by at most max(1%, 1024 bytes) in either
+// measure. Intentional size changes must update the baseline in the same
+// PR (run with --update and commit the diff) so growth is always visible
+// in review.
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+
+const repoRoot = path.resolve(__dirname, "../..");
+const baselinePath = path.join(__dirname, "baseline.json");
+
+const TRACKED = /\.(js|wasm|mem)$/;
+const PCT_TOLERANCE = 0.01;
+const ABS_TOLERANCE = 1024;
+
+const args = process.argv.slice(2);
+const update = args.includes("--update");
+const artIdx = args.indexOf("--artifacts");
+const artifactsDir = artIdx >= 0 ? path.resolve(args[artIdx + 1]) : null;
+
+function collectDists() {
+  const sizes = {};
+  const packagesDir = path.join(repoRoot, "packages");
+  const entries = artifactsDir
+    ? fs
+        .readdirSync(artifactsDir)
+        .filter((d) => d.startsWith("dist-"))
+        .map((d) => ({ pkg: d.slice(5), dir: path.join(artifactsDir, d) }))
+    : fs
+        .readdirSync(packagesDir)
+        .map((p) => ({ pkg: p, dir: path.join(packagesDir, p, "dist") }));
+
+  for (const { pkg, dir } of entries) {
+    if (!fs.existsSync(dir)) continue;
+    const files = fs.readdirSync(dir).filter((f) => TRACKED.test(f)).sort();
+    if (!files.length) continue;
+    sizes[pkg] = {};
+    for (const f of files) {
+      const buf = fs.readFileSync(path.join(dir, f));
+      sizes[pkg][f] = {
+        raw: buf.length,
+        gzip: zlib.gzipSync(buf, { level: 9 }).length,
+      };
+    }
+  }
+  return sizes;
+}
+
+const kib = (n) => (n / 1024).toFixed(1) + " KiB";
+const pct = (now, base) => (((now - base) / base) * 100).toFixed(2) + "%";
+
+const current = collectDists();
+
+if (update) {
+  fs.writeFileSync(baselinePath, JSON.stringify(current, null, 2) + "\n");
+  console.log(`baseline.json updated (${Object.keys(current).length} packages)`);
+  process.exit(0);
+}
+
+if (!fs.existsSync(baselinePath)) {
+  console.error("baseline.json missing — run with --update to create it");
+  process.exit(1);
+}
+const baseline = JSON.parse(fs.readFileSync(baselinePath, "utf8"));
+
+let failures = 0;
+const report = [];
+
+for (const [pkg, files] of Object.entries(baseline)) {
+  if (!current[pkg]) {
+    report.push(`FAIL ${pkg}: no dist built (baseline expects ${Object.keys(files).length} files)`);
+    failures++;
+    continue;
+  }
+  for (const [file, base] of Object.entries(files)) {
+    const now = current[pkg][file];
+    if (!now) {
+      report.push(`FAIL ${pkg}/${file}: missing from build (in baseline: ${kib(base.raw)})`);
+      failures++;
+      continue;
+    }
+    for (const measure of ["raw", "gzip"]) {
+      const allowed = base[measure] + Math.max(base[measure] * PCT_TOLERANCE, ABS_TOLERANCE);
+      const delta = now[measure] - base[measure];
+      const change =
+        delta === 0
+          ? "identical"
+          : `${delta >= 0 ? "+" : ""}${pct(now[measure], base[measure])}`;
+      const line = `${pkg}/${file} [${measure}] ${kib(base[measure])} -> ${kib(now[measure])} (${change})`;
+      if (now[measure] > allowed) {
+        report.push(`FAIL ${line} — exceeds tolerance. If intentional, run 'node tools/dist-size/check.js --update' after a CI-equivalent build and commit baseline.json.`);
+        failures++;
+      } else {
+        report.push(`  ok ${line}`);
+      }
+    }
+  }
+  for (const file of Object.keys(current[pkg])) {
+    if (!files[file]) {
+      report.push(`FAIL ${pkg}/${file}: new artifact not in baseline (${kib(current[pkg][file].raw)}) — add it via --update so the addition is deliberate`);
+      failures++;
+    }
+  }
+}
+for (const pkg of Object.keys(current)) {
+  if (!baseline[pkg]) {
+    report.push(`FAIL ${pkg}: package has dist artifacts but no baseline entry — add via --update`);
+    failures++;
+  }
+}
+
+console.log(report.join("\n"));
+console.log(`\n${failures === 0 ? "PASS" : "FAIL"}: ${failures} size regression(s)`);
+process.exit(failures ? 1 : 0);
diff --git a/tools/fixture-verification/README.md b/tools/fixture-verification/README.md
new file mode 100644
index 0000000..89464c5
--- /dev/null
+++ b/tools/fixture-verification/README.md
@@ -0,0 +1,93 @@
+# Fixture verification
+
+Independent, from-scratch decoders used to verify that the `.raw`/`.RAW`
+pixel references committed under `packages/*/test/fixtures` are correct.
+They share **no code** with the codecs under test (the emscripten wasm
+builds, `jpeg-lossless-decoder-js`, or dicom-codec's `rleLossless.js`), so
+byte-exact agreement means two independent implementations produce the
+same pixels from the same codestream.
+
+```
+node tools/fixture-verification/run-all.js
+```
+
+Exit code 0 and `12/12 checks byte-exact` means every verifiable fixture
+matches.
+
+## What is covered, and how
+
+| Decoder | File | Spec | Verifies |
+|---|---|---|---|
+| JPEG-LS (LOCO-I) | `jls.js` | ITU-T T.87 (regular + run mode, NEAR >= 0, LSE presets) | `charls` CT1.RAW, CT2.RAW, CT-512x512-near-lossless.RAW |
+| JPEG Lossless | `jpll.js` | ITU-T T.81 process 14, SOF3, predictors 1-7 | `dicom-codec` CT-512x512.raw (via both .jpll fixtures) |
+| DICOM RLE | `rle.js` | PS3.5 Annex G | `dicom-codec` CT-512x512.raw |
+| Sequential DCT JPEG | `jpegdct.js` | ITU-T T.81 SOF0/SOF1, restart intervals; integer "islow" IDCT with libjpeg's exact fixed-point constants (PASS1_BITS 2 for 8-bit, 1 for 12-bit) | `libjpeg-turbo-8bit` jpeg400jfif.raw, `libjpeg-turbo-12bit` CT-512x512-12bit.raw |
+
+The openjpeg (J2K) and openjphjs (HTJ2K) CT1/CT2 references are validated
+transitively: those packages' fixtures encode the same two CT slices as
+charls, and `run-all.js` asserts the three packages' RAW files are
+byte-identical, so the from-scratch JPEG-LS decode pins all of them.
+
+Additional independent confirmation performed while creating the
+references (not automated here because it needs external tools): DCMTK's
+`dcmdjpeg` decodes the JPEG Lossless fixtures and the 12-bit JPEG fixture
+to the same bytes.
+
+## Known limitations
+
+- `openjpeg/test/fixtures/raw/CT-512x512-lossy.raw` cannot be verified by
+  an independent decoder: the 9/7 irreversible wavelet makes lossy J2K
+  output implementation-defined. It is a regression golden pinning the
+  openjpeg build's own deterministic output (identical across the asm.js,
+  wasm and decode-only variants).
+- The openjphjs corpus SHA-256 pins (`test/corpus.test.js`) beyond CT1/CT2
+  are likewise regression goldens of the OpenJPH build's output.
+- A byte-exact IDCT match for the DCT JPEGs is possible because
+  libjpeg-turbo's C `islow` path is deterministic; a different IDCT
+  implementation would legitimately differ by +-1. If libjpeg-turbo is ever
+  rebuilt with SIMD enabled, re-check rather than assume.
+
+## Derived color / bit-depth fixtures (plans 034/035)
+
+`gen/generate-fixtures.mjs` produces the color and bit-depth fixtures from
+committed sources (US1.RAW RGB frame, CT2.RAW CT slice) through the wasm
+encoders; `gen/derive.mjs` holds the deterministic transforms the tests use
+to re-derive lossless references. Verification performed 2026-07-07:
+
+- charls US1-color-ilv-sample.jls: byte-identical decode by
+  pylibjpeg-libjpeg (independent JPEG-LS implementation).
+- charls SC1.JLS (shipped, 12-bit): pylibjpeg-libjpeg agrees on all
+  5,093,376 samples; the same image's SC1.j2c (openjphjs) and SC1.j2k
+  (openjpeg) decodes are byte-identical — three codecs, one pixel truth.
+- libjpeg-turbo-8bit US1-color-420 golden: byte-identical to DCMTK
+  dcmdjpeg (YBR_FULL_422 -> RGB), 0 of 921600 bytes differ.
+- libjpeg-turbo-8bit jpeg400jfif-new (progressive SOF2) golden:
+  byte-identical to Pillow's independently built libjpeg.
+- HTJ2K / J2K / RLE color and gray fixtures are lossless: the tests compare
+  against the source bytes themselves.
+
+Two real bugs were found while creating these:
+- `HTJ2KEncoder.hpp` computed the row stride as `bitsPerSample / 8`
+  (truncating to 1 for 9..15-bit samples), corrupting every row after the
+  first for 12-bit encodes.
+- dicom-codec's `adaptImageInfo` dropped `planarConfiguration`, making the
+  RLE plane-sequential path (`decode8Planar`) unreachable via the public
+  API.
+
+## Known limitation of the from-scratch JPEG-LS decoder
+
+`jls.js` disagrees with CharLS/pylibjpeg on `SC1.JLS` (12-bit, run-mode
+heavy) — first divergence at sample (y=32, x=716) in a run-interruption
+context, with CharLS and pylibjpeg agreeing with each other. The bug is in
+`jls.js`, not the fixture; the CT-profile checks it performs in run-all.js
+remain valid (independently confirmed by DCMTK/RLE cross-checks). Fixing
+the 12-bit run-interruption path here is a TODO.
+
+## Bug found by this verification
+
+`jpeg-lossless-decoder-js` (used by dicom-codec for transfer syntaxes
+.57/.70) decodes the final pixel of the SV1 fixture as 0 instead of -2000.
+Four independent decoders agree the fixture is correct: the from-scratch
+`jpll.js` here, DCMTK's `dcmdjpeg`, the RLE decode of the same slice, and
+the library's own Process-14 path. See the pinned `it.fails` test in
+`packages/dicom-codec/test/integration.test.js`.
diff --git a/tools/fixture-verification/gen/derive.mjs b/tools/fixture-verification/gen/derive.mjs
new file mode 100644
index 0000000..8dee61c
--- /dev/null
+++ b/tools/fixture-verification/gen/derive.mjs
@@ -0,0 +1,77 @@
+// Deterministic transforms shared between fixture generation
+// (generate-fixtures.mjs) and the tests that verify lossless round-trips:
+// tests re-derive the expected pixels from the committed source RAWs with
+// these exact functions, so no extra golden files are needed for lossless
+// fixtures.
+
+/**
+ * CT2.RAW (int16le) -> Uint8Array: ((v + 32768) >> 4) & 0xff.
+ * Takes bits 4..11 rather than the top byte: CT values span only ~12 bits,
+ * so the top byte would give a ~16-gray-level image; this keeps rich,
+ * high-frequency content that exercises both run and regular coding modes.
+ */
+export function gray8FromCT2(ct2Buffer) {
+  const src = new Int16Array(ct2Buffer.buffer, ct2Buffer.byteOffset, ct2Buffer.length / 2);
+  const out = new Uint8Array(src.length);
+  for (let i = 0; i < src.length; i++) out[i] = ((src[i] + 32768) >> 4) & 0xff;
+  return out;
+}
+
+/** CT2.RAW (int16le) -> 12-bit unsigned Uint16Array: (v + 32768) >> 4 */
+export function gray12FromCT2(ct2Buffer) {
+  const src = new Int16Array(ct2Buffer.buffer, ct2Buffer.byteOffset, ct2Buffer.length / 2);
+  const out = new Uint16Array(src.length);
+  for (let i = 0; i < src.length; i++) out[i] = (src[i] + 32768) >> 4;
+  return out;
+}
+
+/** CT2.RAW (int16le) -> 16-bit unsigned Uint16Array: v + 32768 */
+export function gray16uFromCT2(ct2Buffer) {
+  const src = new Int16Array(ct2Buffer.buffer, ct2Buffer.byteOffset, ct2Buffer.length / 2);
+  const out = new Uint16Array(src.length);
+  for (let i = 0; i < src.length; i++) out[i] = src[i] + 32768;
+  return out;
+}
+
+/** interleaved RGBRGB... -> [RRR..., GGG..., BBB...] plane buffers */
+export function deinterleavePlanes(buf, samples) {
+  const frameSize = buf.length / samples;
+  const planes = [];
+  for (let s = 0; s < samples; s++) {
+    const plane = Buffer.alloc(frameSize);
+    for (let i = 0; i < frameSize; i++) plane[i] = buf[i * samples + s];
+    planes.push(plane);
+  }
+  return planes;
+}
+
+/** PackBits-encode one DICOM RLE segment (PS3.5 G.3.1), padded to even length */
+export function packBitsSegment(plane) {
+  const out = [];
+  let i = 0;
+  while (i < plane.length) {
+    // find run length at i
+    let run = 1;
+    while (run < 128 && i + run < plane.length && plane[i + run] === plane[i]) run++;
+    if (run >= 2) {
+      out.push(Buffer.from([256 - (run - 1), plane[i]])); // replicate: -(run-1) as int8
+      i += run;
+    } else {
+      // literal run: gather until next replicate run of >=3 or 128 bytes
+      let lit = i + 1;
+      while (
+        lit < plane.length &&
+        lit - i < 128 &&
+        !(lit + 2 < plane.length && plane[lit] === plane[lit + 1] && plane[lit] === plane[lit + 2])
+      ) {
+        lit++;
+      }
+      const chunk = plane.subarray(i, lit);
+      out.push(Buffer.from([chunk.length - 1]), chunk);
+      i = lit;
+    }
+  }
+  let seg = Buffer.concat(out);
+  if (seg.length % 2) seg = Buffer.concat([seg, Buffer.from([0x00])]); // pad per PS3.5 G.3.1
+  return seg;
+}
diff --git a/tools/fixture-verification/gen/generate-fixtures.mjs b/tools/fixture-verification/gen/generate-fixtures.mjs
new file mode 100644
index 0000000..bf49cef
--- /dev/null
+++ b/tools/fixture-verification/gen/generate-fixtures.mjs
@@ -0,0 +1,110 @@
+// Generates the derived test fixtures for color and bit-depth coverage.
+// Deterministic: every fixture is produced from data already committed in
+// the repo (US1.RAW ultrasound RGB frame, CT2.RAW 16-bit CT slice) through
+// the wasm encoders, so re-running this script after a codec change shows
+// exactly which fixtures change and why.
+//
+// Usage: node tools/fixture-verification/gen/generate-fixtures.mjs
+// Requires built dists (see BENCHMARKING.md / docker emsdk build).
+//
+// Lossless fixtures need no golden files: their reference is the source
+// buffer itself, re-derived inside the tests with the same transforms
+// exported from ./derive.mjs. The one lossy fixture (color JPEG) gets a
+// committed .raw golden, cross-verified against DCMTK (see plan 034 /
+// tools/fixture-verification/README.md).
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gray8FromCT2, gray12FromCT2, gray16uFromCT2, deinterleavePlanes, packBitsSegment } from "./derive.mjs";
+
+// getDecodedBuffer() returns a BYTE view; setting a Uint16Array into it
+// would truncate every sample to its low byte. Always hand over bytes.
+const bytes = (ta) => (ta instanceof Uint8Array && !(ta instanceof Buffer) ? ta : new Uint8Array(ta.buffer, ta.byteOffset ?? 0, ta.byteLength ?? ta.length));
+
+const repo = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
+const P = (p) => resolve(repo, "packages", p);
+
+async function load(pkg, file) {
+  const mod = await import(P(`${pkg}/dist/${file}`));
+  const factory = mod.default ?? mod;
+  return await factory();
+}
+
+const us1 = readFileSync(P("openjpeg/test/fixtures/raw/US1.RAW")); // 640x480x3 interleaved RGB
+const ct2 = readFileSync(P("charls/test/fixtures/CT2.RAW")); // 512x512 int16le
+const RGB = { width: 640, height: 480, bitsPerSample: 8, componentCount: 3, isSigned: false };
+const GRAY = (bps) => ({ width: 512, height: 512, bitsPerSample: bps, componentCount: 1, isSigned: false });
+
+// ---- charls ----
+{
+  const codec = await load("charls", "charlsjs.js");
+  const enc = (frameInfo, src, ilv, near = 0) => {
+    const e = new codec.JpegLSEncoder();
+    e.getDecodedBuffer(frameInfo).set(bytes(src));
+    e.setInterleaveMode(ilv);
+    e.setNearLossless(near);
+    e.encode();
+    const out = Buffer.from(e.getEncodedBuffer());
+    e.delete();
+    return out;
+  };
+  // interleave mode 2 (sample): source and decoded output are interleaved RGB
+  writeFileSync(P("charls/test/fixtures/US1-color-ilv-sample.jls"), enc(RGB, us1, 2));
+  writeFileSync(P("charls/test/fixtures/CT2-gray8.jls"), enc(GRAY(8), gray8FromCT2(ct2), 0));
+  writeFileSync(P("charls/test/fixtures/CT2-gray16u.jls"), enc(GRAY(16), gray16uFromCT2(ct2), 0));
+  console.log("charls fixtures written");
+}
+
+// ---- openjphjs (HTJ2K) ----
+{
+  const codec = await load("openjphjs", "openjphjs.js");
+  const enc = (frameInfo, src) => {
+    const e = new codec.HTJ2KEncoder();
+    e.getDecodedBuffer(frameInfo).set(bytes(src));
+    e.encode();
+    const out = Buffer.from(e.getEncodedBuffer());
+    e.delete();
+    return out;
+  };
+  writeFileSync(P("openjphjs/test/fixtures/j2c/US1-color-nct.j2c"), enc({ ...RGB, isUsingColorTransform: false }, us1));
+  writeFileSync(P("openjphjs/test/fixtures/j2c/US1-color-ct.j2c"), enc({ ...RGB, isUsingColorTransform: true }, us1));
+  writeFileSync(P("openjphjs/test/fixtures/j2c/CT2-gray8.j2c"), enc({ ...GRAY(8), isUsingColorTransform: false }, gray8FromCT2(ct2)));
+  writeFileSync(P("openjphjs/test/fixtures/j2c/CT2-gray12.j2c"), enc({ ...GRAY(12), isUsingColorTransform: false }, gray12FromCT2(ct2)));
+  console.log("openjphjs fixtures written");
+}
+
+// ---- libjpeg-turbo-8bit (lossy color JPEG + committed golden) ----
+{
+  const codec = await load("libjpeg-turbo-8bit", "libjpegturbowasm.js");
+  const e = new codec.JPEGEncoder();
+  e.getDecodedBuffer(RGB).set(us1);
+  e.encode();
+  const jpg = Buffer.from(e.getEncodedBuffer());
+  e.delete();
+  writeFileSync(P("libjpeg-turbo-8bit/test/fixtures/jpeg/US1-color-420.jpg"), jpg);
+
+  const d = new codec.JPEGDecoder();
+  d.getEncodedBuffer(jpg.length).set(jpg);
+  d.decode();
+  const golden = Buffer.from(d.getDecodedBuffer());
+  d.delete();
+  writeFileSync(P("libjpeg-turbo-8bit/test/fixtures/raw/US1-color-420.raw"), golden);
+  console.log("libjpeg-turbo-8bit color fixture + golden written (verify vs DCMTK!)");
+}
+
+// ---- dicom-codec (DICOM RLE, 3 segments = planar color) ----
+{
+  const planes = deinterleavePlanes(us1, 3);
+  const segments = planes.map(packBitsSegment);
+  const header = Buffer.alloc(64);
+  header.writeUInt32LE(3, 0);
+  let off = 64;
+  segments.forEach((seg, i) => {
+    header.writeUInt32LE(off, 4 * (i + 1));
+    off += seg.length;
+  });
+  writeFileSync(P("dicom-codec/test/fixtures/rle/US1-color.rle"), Buffer.concat([header, ...segments]));
+  console.log("dicom-codec RLE color fixture written");
+}
+
+console.log("DONE");
diff --git a/tools/fixture-verification/jls.js b/tools/fixture-verification/jls.js
new file mode 100644
index 0000000..0902062
--- /dev/null
+++ b/tools/fixture-verification/jls.js
@@ -0,0 +1,272 @@
+// From-scratch JPEG-LS (ITU-T T.87 / LOCO-I) decoder.
+// Supports: single component (ILV=0), lossless (NEAR=0) and near-lossless
+// (NEAR>0), LSE preset parameters, no restart markers.
+"use strict";
+
+const J = [
+  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
+  4, 4, 5, 5, 6, 6, 7, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+];
+const MIN_C = -128;
+const MAX_C = 127;
+
+class JlsBitReader {
+  // T.87 bit-stuffing: after an 0xFF byte, the following byte contributes
+  // only 7 bits (its MSB must be 0; MSB 1 would be a marker).
+  constructor(buf, pos) {
+    this.buf = buf;
+    this.pos = pos;
+    this.bitBuf = 0;
+    this.bitCount = 0;
+    this.prevWasFF = false;
+  }
+  _load() {
+    const byte = this.buf[this.pos++];
+    if (this.prevWasFF) {
+      if (byte & 0x80) throw new Error("marker inside entropy data");
+      this.bitBuf = (this.bitBuf << 7) | byte;
+      this.bitCount += 7;
+      this.prevWasFF = false;
+    } else {
+      this.bitBuf = (this.bitBuf << 8) | byte;
+      this.bitCount += 8;
+      this.prevWasFF = byte === 0xff;
+    }
+  }
+  readBit() {
+    if (this.bitCount === 0) this._load();
+    this.bitCount--;
+    return (this.bitBuf >>> this.bitCount) & 1;
+  }
+  readBits(n) {
+    let v = 0;
+    for (let i = 0; i < n; i++) v = v * 2 + this.readBit();
+    return v;
+  }
+}
+
+function decodeJLS(buf) {
+  // ---- header ----
+  let i = 2;
+  let P, H, W;
+  let MAXVAL = null, T1 = null, T2 = null, T3 = null, RESET = 64;
+  let NEAR = 0;
+  for (;;) {
+    if (buf[i] !== 0xff) throw new Error(`expected marker at ${i}`);
+    const m = buf[i + 1];
+    const len = (buf[i + 2] << 8) | buf[i + 3];
+    if (m === 0xf7) {
+      P = buf[i + 4];
+      H = (buf[i + 5] << 8) | buf[i + 6];
+      W = (buf[i + 7] << 8) | buf[i + 8];
+      if (buf[i + 9] !== 1) throw new Error("only single-component supported");
+    } else if (m === 0xf8 && buf[i + 4] === 1) {
+      MAXVAL = (buf[i + 5] << 8) | buf[i + 6];
+      T1 = (buf[i + 7] << 8) | buf[i + 8];
+      T2 = (buf[i + 9] << 8) | buf[i + 10];
+      T3 = (buf[i + 11] << 8) | buf[i + 12];
+      RESET = (buf[i + 13] << 8) | buf[i + 14];
+    } else if (m === 0xda) {
+      const Ns = buf[i + 4];
+      if (Ns !== 1) throw new Error("only single-scan supported");
+      NEAR = buf[i + 5 + 2 * Ns];
+      const ILV = buf[i + 6 + 2 * Ns];
+      if (ILV !== 0) throw new Error("only ILV=0 supported");
+      i = i + 2 + len;
+      break;
+    }
+    i += 2 + len;
+  }
+
+  if (MAXVAL === null) MAXVAL = (1 << P) - 1;
+  // C.2.4.1.1 defaults (only used if LSE absent; our fixtures carry LSE)
+  if (T1 === null) throw new Error("defaults not implemented; LSE expected");
+
+  // ---- derived parameters (A.2.1 / A.5) ----
+  const RANGE = Math.floor((MAXVAL + 2 * NEAR) / (2 * NEAR + 1)) + 1;
+  const qbpp = Math.ceil(Math.log2(RANGE));
+  const bpp = Math.max(2, Math.ceil(Math.log2(MAXVAL + 1)));
+  const LIMIT = 2 * (bpp + Math.max(8, bpp));
+  const AINIT = Math.max(2, Math.floor((RANGE + 32) / 64));
+
+  const A = new Int32Array(367).fill(AINIT);
+  const B = new Int32Array(365);
+  const C = new Int32Array(365);
+  const N = new Int32Array(367).fill(1);
+  const Nn = new Int32Array(2); // for contexts 365 (RItype 0) and 366 (RItype 1)
+  let RUNindex = 0;
+
+  const reader = new JlsBitReader(buf, i);
+
+  const golomb = (k, glimit) => {
+    // A.5.3 limited-length Golomb decode
+    let z = 0;
+    while (reader.readBit() === 0) z++;
+    if (z < glimit) return z * (1 << k) + reader.readBits(k);
+    return reader.readBits(qbpp) + 1;
+  };
+
+  const quantize = (d) => {
+    // C.2.3 gradient quantization (signs handled symmetrically)
+    if (d <= -T3) return -4;
+    if (d <= -T2) return -3;
+    if (d <= -T1) return -2;
+    if (d < -NEAR) return -1;
+    if (d <= NEAR) return 0;
+    if (d < T1) return 1;
+    if (d < T2) return 2;
+    if (d < T3) return 3;
+    return 4;
+  };
+
+  const modRangeFix = (rx) => {
+    if (rx < -NEAR) rx += RANGE * (2 * NEAR + 1);
+    else if (rx > MAXVAL + NEAR) rx -= RANGE * (2 * NEAR + 1);
+    if (rx < 0) rx = 0;
+    else if (rx > MAXVAL) rx = MAXVAL;
+    return rx;
+  };
+
+  // line buffers with 1 slack element each side; samples at 1..W
+  let prev = new Int32Array(W + 2);
+  let cur = new Int32Array(W + 2);
+
+  const out = new Uint16Array(W * H);
+
+  for (let y = 0; y < H; y++) {
+    cur[0] = prev[1]; // Ra for x=0 is Rb; becomes Rc for the next line
+    let x = 1;
+    while (x <= W) {
+      const Ra = cur[x - 1];
+      const Rb = prev[x];
+      const Rc = prev[x - 1];
+      const Rd = prev[x + 1];
+      const D1 = Rd - Rb;
+      const D2 = Rb - Rc;
+      const D3 = Rc - Ra;
+
+      if (Math.abs(D1) <= NEAR && Math.abs(D2) <= NEAR && Math.abs(D3) <= NEAR) {
+        // ---- run mode (A.7) ----
+        const runVal = Ra;
+        let interrupted = false;
+        for (;;) {
+          if (reader.readBit() === 1) {
+            const segLen = 1 << J[RUNindex];
+            const n = Math.min(segLen, W - x + 1);
+            for (let f = 0; f < n; f++) cur[x++] = runVal;
+            if (n === segLen && RUNindex < 31) RUNindex++;
+            if (x > W) break; // run ended by end of line: no interruption sample
+          } else {
+            const cnt = J[RUNindex] > 0 ? reader.readBits(J[RUNindex]) : 0;
+            for (let f = 0; f < cnt; f++) cur[x++] = runVal;
+            interrupted = true;
+            break;
+          }
+        }
+        if (interrupted) {
+          // ---- run interruption sample (A.7.2) ----
+          const RaI = cur[x - 1];
+          const RbI = prev[x];
+          const RItype = Math.abs(RaI - RbI) <= NEAR ? 1 : 0;
+          const Px = RItype === 1 ? RaI : RbI;
+          const SIGN = RItype === 0 && RaI > RbI ? -1 : 1;
+          const q = 365 + RItype;
+          // A.7.2.1: TEMP = A[366] + (N[366]>>1) for RItype 1, A[365] for RItype 0
+          const TEMP = RItype === 1 ? A[366] + (N[366] >> 1) : A[365];
+          let k = 0;
+          while (N[q] << k < TEMP) k++;
+          const glimit = LIMIT - J[RUNindex] - 1;
+          const EM = golomb(k, glimit);
+          const tmp = EM + RItype;
+          // invert the A.7.2.1 error mapping
+          const cond = k === 0 && 2 * Nn[RItype] < N[q];
+          let Errval;
+          if (tmp === 0) Errval = 0;
+          else if (cond) Errval = tmp % 2 === 1 ? (tmp + 1) / 2 : -(tmp / 2);
+          else Errval = tmp % 2 === 0 ? tmp / 2 : -((tmp + 1) / 2);
+          if (Errval < 0) Nn[RItype]++;
+
+          const Rx = modRangeFix(Px + SIGN * Errval * (2 * NEAR + 1));
+          cur[x++] = Rx;
+
+          A[q] += (EM + 1 - RItype) >> 1;
+          if (N[q] === RESET) {
+            A[q] >>= 1;
+            N[q] >>= 1;
+            Nn[RItype] >>= 1;
+          }
+          N[q]++;
+          if (RUNindex > 0) RUNindex--;
+        }
+      } else {
+        // ---- regular mode (A.4-A.6) ----
+        let Q1 = quantize(D1);
+        let Q2 = quantize(D2);
+        let Q3 = quantize(D3);
+        let SIGN = 1;
+        let q = 81 * Q1 + 9 * Q2 + Q3;
+        if (q < 0) {
+          SIGN = -1;
+          q = -q;
+        }
+        q -= 1; // contexts 1..364 -> 0-based storage
+        // MED predictor
+        let Px;
+        const minAB = Math.min(Ra, Rb);
+        const maxAB = Math.max(Ra, Rb);
+        if (Rc >= maxAB) Px = minAB;
+        else if (Rc <= minAB) Px = maxAB;
+        else Px = Ra + Rb - Rc;
+        Px += SIGN * C[q];
+        if (Px < 0) Px = 0;
+        else if (Px > MAXVAL) Px = MAXVAL;
+
+        let k = 0;
+        while (N[q] << k < A[q]) k++;
+        const MErr = golomb(k, LIMIT - qbpp - 1);
+        let Errval;
+        if (NEAR === 0 && k === 0 && 2 * B[q] <= -N[q]) {
+          // inverted mapping under negative bias (A.5.4)
+          Errval = MErr % 2 === 1 ? (MErr - 1) / 2 : -(MErr / 2) - 1;
+        } else {
+          Errval = MErr % 2 === 0 ? MErr / 2 : -((MErr + 1) / 2);
+        }
+
+        const Rx = modRangeFix(Px + SIGN * Errval * (2 * NEAR + 1));
+        cur[x++] = Rx;
+
+        // context update (A.6)
+        B[q] += Errval * (2 * NEAR + 1);
+        A[q] += Math.abs(Errval);
+        if (N[q] === RESET) {
+          A[q] >>= 1;
+          B[q] >>= 1;
+          N[q] >>= 1;
+        }
+        N[q]++;
+        // bias computation (A.6.2)
+        if (B[q] <= -N[q]) {
+          B[q] += N[q];
+          if (C[q] > MIN_C) C[q]--;
+          if (B[q] <= -N[q]) B[q] = -N[q] + 1;
+        } else if (B[q] > 0) {
+          B[q] -= N[q];
+          if (C[q] < MAX_C) C[q]++;
+          if (B[q] > 0) B[q] = 0;
+        }
+      }
+    }
+    // copy decoded line to output, then swap buffers
+    for (let xx = 1; xx <= W; xx++) out[y * W + xx - 1] = cur[xx];
+    const t = prev;
+    prev = cur;
+    cur = t;
+    prev[W + 1] = prev[W]; // Rd at the last column
+  }
+
+  const bytes = Buffer.alloc(out.length * 2);
+  for (let k2 = 0; k2 < out.length; k2++) bytes.writeUInt16LE(out[k2], k2 * 2);
+  return { bytes, NEAR, MAXVAL, T1, T2, T3, RESET, W, H, P };
+}
+
+module.exports = { decodeJLS };
diff --git a/tools/fixture-verification/jpegdct.js b/tools/fixture-verification/jpegdct.js
new file mode 100644
index 0000000..b04121c
--- /dev/null
+++ b/tools/fixture-verification/jpegdct.js
@@ -0,0 +1,324 @@
+// From-scratch sequential DCT JPEG decoder (T.81): baseline 8-bit (SOF0)
+// and extended sequential 12-bit (SOF1), single component, restart
+// intervals supported. The IDCT is the classic Loeffler-Ligtenberg-Moshovitz
+// integer algorithm with libjpeg's "islow" fixed-point constants and
+// descaling, so output should be bit-identical to libjpeg's C islow path.
+"use strict";
+
+const ZIGZAG = [
+  0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
+  12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
+  35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
+  58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
+];
+
+const CONST_BITS = 13;
+// libjpeg jidctint.c: PASS1_BITS is 2 for 8-bit samples, 1 for 9..12-bit
+// (keeps intermediates inside 32 bits in the C implementation)
+const FIX_0_298631336 = 2446;
+const FIX_0_390180644 = 3196;
+const FIX_0_541196100 = 4433;
+const FIX_0_765366865 = 6270;
+const FIX_0_899976223 = 7373;
+const FIX_1_175875602 = 9633;
+const FIX_1_501321110 = 12299;
+const FIX_1_847759065 = 15137;
+const FIX_1_961570560 = 16069;
+const FIX_2_053119869 = 16819;
+const FIX_2_562915447 = 20995;
+const FIX_3_072711026 = 25172;
+
+const DESCALE = (x, n) => Math.floor((x + (1 << (n - 1))) / (1 << n));
+
+// 8x8 islow IDCT: coef (natural order, already dequantized) -> samples
+function idctIslow(coef, out, center, maxval, PASS1_BITS) {
+  const ws = new Array(64);
+  // pass 1: columns
+  for (let c = 0; c < 8; c++) {
+    if (
+      coef[c + 8] === 0 && coef[c + 16] === 0 && coef[c + 24] === 0 &&
+      coef[c + 32] === 0 && coef[c + 40] === 0 && coef[c + 48] === 0 &&
+      coef[c + 56] === 0
+    ) {
+      const dc = coef[c] * (1 << PASS1_BITS);
+      for (let r = 0; r < 8; r++) ws[c + 8 * r] = dc;
+      continue;
+    }
+    let z2 = coef[c + 16];
+    let z3 = coef[c + 48];
+    let z1 = (z2 + z3) * FIX_0_541196100;
+    let tmp2 = z1 + z3 * -FIX_1_847759065;
+    let tmp3 = z1 + z2 * FIX_0_765366865;
+    z2 = coef[c];
+    z3 = coef[c + 32];
+    let tmp0 = (z2 + z3) * (1 << CONST_BITS);
+    let tmp1 = (z2 - z3) * (1 << CONST_BITS);
+    const tmp10 = tmp0 + tmp3;
+    const tmp13 = tmp0 - tmp3;
+    const tmp11 = tmp1 + tmp2;
+    const tmp12 = tmp1 - tmp2;
+    tmp0 = coef[c + 56];
+    tmp1 = coef[c + 40];
+    tmp2 = coef[c + 24];
+    tmp3 = coef[c + 8];
+    z1 = tmp0 + tmp3;
+    z2 = tmp1 + tmp2;
+    z3 = tmp0 + tmp2;
+    let z4 = tmp1 + tmp3;
+    const z5 = (z3 + z4) * FIX_1_175875602;
+    tmp0 *= FIX_0_298631336;
+    tmp1 *= FIX_2_053119869;
+    tmp2 *= FIX_3_072711026;
+    tmp3 *= FIX_1_501321110;
+    z1 *= -FIX_0_899976223;
+    z2 *= -FIX_2_562915447;
+    z3 = z3 * -FIX_1_961570560 + z5;
+    z4 = z4 * -FIX_0_390180644 + z5;
+    tmp0 += z1 + z3;
+    tmp1 += z2 + z4;
+    tmp2 += z2 + z3;
+    tmp3 += z1 + z4;
+    ws[c] = DESCALE(tmp10 + tmp3, CONST_BITS - PASS1_BITS);
+    ws[c + 56] = DESCALE(tmp10 - tmp3, CONST_BITS - PASS1_BITS);
+    ws[c + 8] = DESCALE(tmp11 + tmp2, CONST_BITS - PASS1_BITS);
+    ws[c + 48] = DESCALE(tmp11 - tmp2, CONST_BITS - PASS1_BITS);
+    ws[c + 16] = DESCALE(tmp12 + tmp1, CONST_BITS - PASS1_BITS);
+    ws[c + 40] = DESCALE(tmp12 - tmp1, CONST_BITS - PASS1_BITS);
+    ws[c + 24] = DESCALE(tmp13 + tmp0, CONST_BITS - PASS1_BITS);
+    ws[c + 32] = DESCALE(tmp13 - tmp0, CONST_BITS - PASS1_BITS);
+  }
+  // pass 2: rows
+  const clamp = (v) => {
+    v += center;
+    return v < 0 ? 0 : v > maxval ? maxval : v;
+  };
+  for (let r = 0; r < 8; r++) {
+    const o = 8 * r;
+    if (
+      ws[o + 1] === 0 && ws[o + 2] === 0 && ws[o + 3] === 0 && ws[o + 4] === 0 &&
+      ws[o + 5] === 0 && ws[o + 6] === 0 && ws[o + 7] === 0
+    ) {
+      const dc = clamp(DESCALE(ws[o], PASS1_BITS + 3));
+      for (let c = 0; c < 8; c++) out[o + c] = dc;
+      continue;
+    }
+    let z2 = ws[o + 2];
+    let z3 = ws[o + 6];
+    let z1 = (z2 + z3) * FIX_0_541196100;
+    let tmp2 = z1 + z3 * -FIX_1_847759065;
+    let tmp3 = z1 + z2 * FIX_0_765366865;
+    let tmp0 = (ws[o] + ws[o + 4]) * (1 << CONST_BITS);
+    let tmp1 = (ws[o] - ws[o + 4]) * (1 << CONST_BITS);
+    const tmp10 = tmp0 + tmp3;
+    const tmp13 = tmp0 - tmp3;
+    const tmp11 = tmp1 + tmp2;
+    const tmp12 = tmp1 - tmp2;
+    tmp0 = ws[o + 7];
+    tmp1 = ws[o + 5];
+    tmp2 = ws[o + 3];
+    tmp3 = ws[o + 1];
+    z1 = tmp0 + tmp3;
+    z2 = tmp1 + tmp2;
+    z3 = tmp0 + tmp2;
+    let z4 = tmp1 + tmp3;
+    const z5 = (z3 + z4) * FIX_1_175875602;
+    tmp0 *= FIX_0_298631336;
+    tmp1 *= FIX_2_053119869;
+    tmp2 *= FIX_3_072711026;
+    tmp3 *= FIX_1_501321110;
+    z1 *= -FIX_0_899976223;
+    z2 *= -FIX_2_562915447;
+    z3 = z3 * -FIX_1_961570560 + z5;
+    z4 = z4 * -FIX_0_390180644 + z5;
+    tmp0 += z1 + z3;
+    tmp1 += z2 + z4;
+    tmp2 += z2 + z3;
+    tmp3 += z1 + z4;
+    out[o] = clamp(DESCALE(tmp10 + tmp3, CONST_BITS + PASS1_BITS + 3));
+    out[o + 7] = clamp(DESCALE(tmp10 - tmp3, CONST_BITS + PASS1_BITS + 3));
+    out[o + 1] = clamp(DESCALE(tmp11 + tmp2, CONST_BITS + PASS1_BITS + 3));
+    out[o + 6] = clamp(DESCALE(tmp11 - tmp2, CONST_BITS + PASS1_BITS + 3));
+    out[o + 2] = clamp(DESCALE(tmp12 + tmp1, CONST_BITS + PASS1_BITS + 3));
+    out[o + 5] = clamp(DESCALE(tmp12 - tmp1, CONST_BITS + PASS1_BITS + 3));
+    out[o + 3] = clamp(DESCALE(tmp13 + tmp0, CONST_BITS + PASS1_BITS + 3));
+    out[o + 4] = clamp(DESCALE(tmp13 - tmp0, CONST_BITS + PASS1_BITS + 3));
+  }
+}
+
+function buildHuffman(counts, symbols) {
+  const lut = new Map();
+  let code = 0;
+  let k = 0;
+  for (let len = 1; len <= 16; len++) {
+    for (let i = 0; i < counts[len - 1]; i++) lut.set(`${len}:${code++}`, symbols[k++]);
+    code <<= 1;
+  }
+  return lut;
+}
+
+class BitReader {
+  constructor(buf, pos) {
+    this.buf = buf;
+    this.pos = pos;
+    this.bitBuf = 0;
+    this.bitCount = 0;
+  }
+  readBit() {
+    if (this.bitCount === 0) {
+      let byte = this.buf[this.pos++];
+      if (byte === 0xff) {
+        if (this.buf[this.pos] === 0x00) this.pos++;
+        else throw new Error(`marker FF${this.buf[this.pos].toString(16)} in entropy data`);
+      }
+      this.bitBuf = byte;
+      this.bitCount = 8;
+    }
+    this.bitCount--;
+    return (this.bitBuf >> this.bitCount) & 1;
+  }
+  readBits(n) {
+    let v = 0;
+    for (let i = 0; i < n; i++) v = (v << 1) | this.readBit();
+    return v;
+  }
+  alignAndConsumeRestart(expected) {
+    this.bitCount = 0;
+    if (this.buf[this.pos] !== 0xff) throw new Error("expected restart marker");
+    const m = this.buf[this.pos + 1];
+    if (m !== 0xd0 + expected) throw new Error(`expected RST${expected}, got FF${m.toString(16)}`);
+    this.pos += 2;
+  }
+}
+
+function decodeHuff(reader, lut) {
+  let code = 0;
+  for (let len = 1; len <= 16; len++) {
+    code = (code << 1) | reader.readBit();
+    const sym = lut.get(`${len}:${code}`);
+    if (sym !== undefined) return sym;
+  }
+  throw new Error("invalid Huffman code");
+}
+
+const extend = (v, t) => (v < 1 << (t - 1) ? v - (1 << t) + 1 : v);
+
+function decodeSequentialDCT(buf) {
+  let i = 2;
+  let P, Y, X;
+  let qt = null;
+  const huffDC = {};
+  const huffAC = {};
+  let restartInterval = 0;
+  for (;;) {
+    if (buf[i] !== 0xff) throw new Error(`expected marker at ${i}`);
+    const m = buf[i + 1];
+    const len = (buf[i + 2] << 8) | buf[i + 3];
+    if (m === 0xdb) {
+      // DQT (single table, 8-bit precision Pq=0 assumed for these fixtures)
+      const pq = buf[i + 4] >> 4;
+      qt = new Int32Array(64);
+      for (let k = 0; k < 64; k++) {
+        qt[ZIGZAG[k]] = pq ? (buf[i + 5 + 2 * k] << 8) | buf[i + 6 + 2 * k] : buf[i + 5 + k];
+      }
+    } else if (m === 0xc0 || m === 0xc1) {
+      P = buf[i + 4];
+      Y = (buf[i + 5] << 8) | buf[i + 6];
+      X = (buf[i + 7] << 8) | buf[i + 8];
+      if (buf[i + 9] !== 1) throw new Error("only single-component supported");
+      if (buf[i + 11] !== 0x11) throw new Error("only 1x1 sampling supported");
+    } else if (m === 0xc4) {
+      // DHT: may contain multiple tables in one segment
+      let p = i + 4;
+      const end = i + 2 + len;
+      while (p < end) {
+        const tcth = buf[p];
+        const counts = Array.from(buf.slice(p + 1, p + 17));
+        const total = counts.reduce((a, b) => a + b, 0);
+        const symbols = Array.from(buf.slice(p + 17, p + 17 + total));
+        const lut = buildHuffman(counts, symbols);
+        if (tcth >> 4 === 0) huffDC[tcth & 15] = lut;
+        else huffAC[tcth & 15] = lut;
+        p += 17 + total;
+      }
+    } else if (m === 0xdd) {
+      restartInterval = (buf[i + 4] << 8) | buf[i + 5];
+    } else if (m === 0xda) {
+      const Ns = buf[i + 4];
+      if (Ns !== 1) throw new Error("only single-scan supported");
+      var dcSel = buf[i + 6] >> 4;
+      var acSel = buf[i + 6] & 15;
+      i = i + 2 + len;
+      break;
+    }
+    i += 2 + len;
+  }
+
+  const reader = new BitReader(buf, i);
+  const dcTab = huffDC[dcSel];
+  const acTab = huffAC[acSel];
+  const maxval = (1 << P) - 1;
+  const center = 1 << (P - 1);
+
+  const blocksX = Math.ceil(X / 8);
+  const blocksY = Math.ceil(Y / 8);
+  const out = P > 8 ? new Uint16Array(X * Y) : new Uint8Array(X * Y);
+
+  let dcPred = 0;
+  let mcu = 0;
+  let restartCount = 0;
+  const coef = new Int32Array(64);
+  const px = new Array(64);
+
+  for (let by = 0; by < blocksY; by++) {
+    for (let bx = 0; bx < blocksX; bx++) {
+      if (restartInterval && mcu > 0 && mcu % restartInterval === 0) {
+        reader.alignAndConsumeRestart(restartCount & 7);
+        restartCount++;
+        dcPred = 0;
+      }
+      mcu++;
+
+      coef.fill(0);
+      const t = decodeHuff(reader, dcTab);
+      const diff = t === 0 ? 0 : extend(reader.readBits(t), t);
+      dcPred += diff;
+      coef[0] = dcPred * qt[0];
+      let k = 1;
+      while (k < 64) {
+        const rs = decodeHuff(reader, acTab);
+        const r = rs >> 4;
+        const s = rs & 15;
+        if (s === 0) {
+          if (r === 15) {
+            k += 16;
+            continue;
+          }
+          break; // EOB
+        }
+        k += r;
+        coef[ZIGZAG[k]] = extend(reader.readBits(s), s) * qt[ZIGZAG[k]];
+        k++;
+      }
+
+      idctIslow(coef, px, center, maxval, P > 8 ? 1 : 2);
+      const w = Math.min(8, X - bx * 8);
+      const h = Math.min(8, Y - by * 8);
+      for (let yy = 0; yy < h; yy++) {
+        for (let xx = 0; xx < w; xx++) {
+          out[(by * 8 + yy) * X + bx * 8 + xx] = px[yy * 8 + xx];
+        }
+      }
+    }
+  }
+
+  let bytes;
+  if (P > 8) {
+    bytes = Buffer.alloc(out.length * 2);
+    for (let k2 = 0; k2 < out.length; k2++) bytes.writeUInt16LE(out[k2], k2 * 2);
+  } else {
+    bytes = Buffer.from(out);
+  }
+  return { bytes, P, X, Y, restartInterval };
+}
+
+module.exports = { decodeSequentialDCT };
diff --git a/tools/fixture-verification/jpll.js b/tools/fixture-verification/jpll.js
new file mode 100644
index 0000000..b5aa9b4
--- /dev/null
+++ b/tools/fixture-verification/jpll.js
@@ -0,0 +1,135 @@
+// From-scratch JPEG Lossless (ITU-T T.81 process 14, SOF3) decoder.
+// Single component, no restart intervals, all 7 predictors supported.
+"use strict";
+
+function buildHuffman(counts, symbols) {
+  // canonical Huffman: map (length, code) -> symbol
+  const lut = new Map();
+  let code = 0;
+  let k = 0;
+  for (let len = 1; len <= 16; len++) {
+    for (let i = 0; i < counts[len - 1]; i++) {
+      lut.set(`${len}:${code}`, symbols[k++]);
+      code++;
+    }
+    code <<= 1;
+  }
+  return lut;
+}
+
+class BitReader {
+  // classic JPEG entropy reader: 0xFF 0x00 is an escaped literal 0xFF
+  constructor(buf, pos) {
+    this.buf = buf;
+    this.pos = pos;
+    this.bitBuf = 0;
+    this.bitCount = 0;
+  }
+  readBit() {
+    if (this.bitCount === 0) {
+      let byte = this.buf[this.pos++];
+      if (byte === 0xff) {
+        const next = this.buf[this.pos];
+        if (next === 0x00) this.pos++;
+        else throw new Error(`unexpected marker FF${next.toString(16)} in entropy data`);
+      }
+      this.bitBuf = byte;
+      this.bitCount = 8;
+    }
+    this.bitCount--;
+    return (this.bitBuf >> this.bitCount) & 1;
+  }
+  readBits(n) {
+    let v = 0;
+    for (let i = 0; i < n; i++) v = (v << 1) | this.readBit();
+    return v;
+  }
+}
+
+function decodeHuff(reader, lut) {
+  let code = 0;
+  for (let len = 1; len <= 16; len++) {
+    code = (code << 1) | reader.readBit();
+    const sym = lut.get(`${len}:${code}`);
+    if (sym !== undefined) return sym;
+  }
+  throw new Error("invalid Huffman code");
+}
+
+function extend(v, t) {
+  // T.81 F.2.2.1 EXTEND
+  return v < 1 << (t - 1) ? v - (1 << t) + 1 : v;
+}
+
+function decodeJPLL(buf) {
+  let i = 2; // skip SOI
+  let P, Y, X, predictor, pointTransform;
+  let huff = null;
+  for (;;) {
+    if (buf[i] !== 0xff) throw new Error(`expected marker at ${i}`);
+    const m = buf[i + 1];
+    const len = (buf[i + 2] << 8) | buf[i + 3];
+    if (m === 0xc3) {
+      P = buf[i + 4];
+      Y = (buf[i + 5] << 8) | buf[i + 6];
+      X = (buf[i + 7] << 8) | buf[i + 8];
+      if (buf[i + 9] !== 1) throw new Error("only single-component supported");
+    } else if (m === 0xc4) {
+      const counts = Array.from(buf.slice(i + 5, i + 21));
+      const total = counts.reduce((a, b) => a + b, 0);
+      const symbols = Array.from(buf.slice(i + 21, i + 21 + total));
+      huff = buildHuffman(counts, symbols);
+    } else if (m === 0xda) {
+      const Ns = buf[i + 4];
+      if (Ns !== 1) throw new Error("only single-scan supported");
+      predictor = buf[i + 5 + 2 * Ns];
+      pointTransform = buf[i + 7 + 2 * Ns] & 0x0f;
+      i = i + 2 + len;
+      break;
+    } else if (m === 0xdd) {
+      throw new Error("restart intervals not supported here");
+    }
+    i += 2 + len;
+  }
+
+  const reader = new BitReader(buf, i);
+  const out = new Uint16Array(X * Y);
+  const defaultPx = 1 << (P - 1 - pointTransform);
+
+  for (let y = 0; y < Y; y++) {
+    for (let x = 0; x < X; x++) {
+      const t = decodeHuff(reader, huff);
+      let diff;
+      if (t === 0) diff = 0;
+      else if (t === 16) diff = 32768;
+      else diff = extend(reader.readBits(t), t);
+
+      let Px;
+      if (y === 0 && x === 0) Px = defaultPx;
+      else if (y === 0) Px = out[x - 1];
+      else if (x === 0) Px = out[(y - 1) * X];
+      else {
+        const Ra = out[y * X + x - 1];
+        const Rb = out[(y - 1) * X + x];
+        const Rc = out[(y - 1) * X + x - 1];
+        switch (predictor) {
+          case 1: Px = Ra; break;
+          case 2: Px = Rb; break;
+          case 3: Px = Rc; break;
+          case 4: Px = Ra + Rb - Rc; break;
+          case 5: Px = Ra + ((Rb - Rc) >> 1); break;
+          case 6: Px = Rb + ((Ra - Rc) >> 1); break;
+          case 7: Px = (Ra + Rb) >> 1; break;
+          default: throw new Error(`bad predictor ${predictor}`);
+        }
+      }
+      out[y * X + x] = (Px + diff) & 0xffff;
+    }
+  }
+
+  const bytes = Buffer.alloc(out.length * 2);
+  for (let k = 0; k < out.length; k++) bytes.writeUInt16LE(out[k], k * 2);
+  return { bytes, predictor, P, X, Y };
+}
+
+module.exports = { decodeJPLL };
diff --git a/tools/fixture-verification/rle.js b/tools/fixture-verification/rle.js
new file mode 100644
index 0000000..0f589a3
--- /dev/null
+++ b/tools/fixture-verification/rle.js
@@ -0,0 +1,44 @@
+// From-scratch DICOM RLE (PS3.5 Annex G) decoder. 16-bit single sample:
+// segment 0 carries the high bytes, segment 1 the low bytes.
+"use strict";
+
+function unpackSegment(buf, start, end, expected) {
+  const out = Buffer.alloc(expected);
+  let i = start;
+  let o = 0;
+  while (i < end && o < expected) {
+    const n = buf.readInt8(i);
+    i += 1;
+    if (n >= 0) {
+      // literal run: copy n+1 bytes
+      buf.copy(out, o, i, i + n + 1);
+      i += n + 1;
+      o += n + 1;
+    } else if (n >= -127) {
+      // replicate run: next byte repeated -n+1 times
+      out.fill(buf[i], o, o + (-n + 1));
+      i += 1;
+      o += -n + 1;
+    }
+    // n === -128: no-op
+  }
+  if (o !== expected) throw new Error(`segment underflow: ${o} of ${expected}`);
+  return out;
+}
+
+function decodeRLE16(buf, width, height) {
+  const numSegments = buf.readUInt32LE(0);
+  if (numSegments !== 2) throw new Error(`expected 2 segments, got ${numSegments}`);
+  const off0 = buf.readUInt32LE(4);
+  const off1 = buf.readUInt32LE(8);
+  const frameSize = width * height;
+  const hi = unpackSegment(buf, off0, off1, frameSize);
+  const lo = unpackSegment(buf, off1, buf.length, frameSize);
+  const out = Buffer.alloc(frameSize * 2);
+  for (let i = 0; i < frameSize; i++) {
+    out.writeUInt16LE((hi[i] << 8) | lo[i], i * 2);
+  }
+  return out;
+}
+
+module.exports = { decodeRLE16 };
diff --git a/tools/fixture-verification/run-all.js b/tools/fixture-verification/run-all.js
new file mode 100644
index 0000000..587ecaa
--- /dev/null
+++ b/tools/fixture-verification/run-all.js
@@ -0,0 +1,63 @@
+// Fixture verification: decode every encoded test fixture with the
+// from-scratch decoders in this directory and binary-compare against the
+// committed .raw/.RAW references. Also asserts cross-package equality of
+// the shared CT1/CT2 references.
+//
+// Usage: node tools/fixture-verification/run-all.js
+//
+// These decoders share no code with the codecs under test (wasm builds,
+// jpeg-lossless-decoder-js, dicom-codec's rleLossless): an agreement here
+// means two independent implementations produce identical pixels.
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const { decodeRLE16 } = require("./rle.js");
+const { decodeJPLL } = require("./jpll.js");
+const { decodeJLS } = require("./jls.js");
+const { decodeSequentialDCT } = require("./jpegdct.js");
+
+const repo = path.resolve(__dirname, "../..");
+const F = (p) => fs.readFileSync(path.join(repo, "packages", p));
+
+const results = [];
+function check(name, actual, expected) {
+  const ok = actual.equals(expected);
+  let detail = "";
+  if (!ok) {
+    let d = 0;
+    for (let i = 0; i < Math.min(actual.length, expected.length); i++)
+      if (actual[i] !== expected[i]) d++;
+    detail = ` (differing bytes: ${d}, lenA=${actual.length}, lenB=${expected.length})`;
+  }
+  results.push([name, ok ? "BYTE-EXACT" : "MISMATCH" + detail]);
+}
+
+// --- JPEG-LS (charls) ---
+check("charls CT1.RAW               <- JPEG-LS(CT1.JLS)", decodeJLS(F("charls/test/fixtures/CT1.JLS")).bytes, F("charls/test/fixtures/CT1.RAW"));
+check("charls CT2.RAW               <- JPEG-LS(CT2.JLS)", decodeJLS(F("charls/test/fixtures/CT2.JLS")).bytes, F("charls/test/fixtures/CT2.RAW"));
+check("charls near-lossless.RAW     <- JPEG-LS(.81, NEAR=1)", decodeJLS(F("charls/test/fixtures/CT-512x512-near-lossless.JLS")).bytes, F("charls/test/fixtures/CT-512x512-near-lossless.RAW"));
+
+// --- shared CT1/CT2 references across packages ---
+// charls, openjpeg and openjph encode the same two CT slices; all three
+// packages must reference identical pixels. Verifying the JPEG-LS decode
+// above therefore also validates the J2K and HTJ2K references below.
+check("openjpeg CT1.RAW             == charls CT1.RAW", F("openjpeg/test/fixtures/raw/CT1.RAW"), F("charls/test/fixtures/CT1.RAW"));
+check("openjpeg CT2.RAW             == charls CT2.RAW", F("openjpeg/test/fixtures/raw/CT2.RAW"), F("charls/test/fixtures/CT2.RAW"));
+check("openjphjs CT1.RAW            == charls CT1.RAW", F("openjphjs/test/fixtures/raw/CT1.RAW"), F("charls/test/fixtures/CT1.RAW"));
+check("openjphjs CT2.RAW            == charls CT2.RAW", F("openjphjs/test/fixtures/raw/CT2.RAW"), F("charls/test/fixtures/CT2.RAW"));
+
+// --- DICOM RLE + JPEG Lossless (dicom-codec) ---
+const ctRaw = F("dicom-codec/test/fixtures/raw/CT-512x512.raw");
+check("dicom-codec CT-512x512.raw   <- RLE decoder", decodeRLE16(F("dicom-codec/test/fixtures/rle/CT-512x512.rle"), 512, 512), ctRaw);
+check("dicom-codec CT-512x512.raw   <- JPEG-Lossless (p14, predictor 6)", decodeJPLL(F("dicom-codec/test/fixtures/jpeg-lossless/CT-512x512-process14.jpll")).bytes, ctRaw);
+check("dicom-codec CT-512x512.raw   <- JPEG-Lossless (sv1, predictor 1)", decodeJPLL(F("dicom-codec/test/fixtures/jpeg-lossless/CT-512x512-process14-sv1.jpll")).bytes, ctRaw);
+
+// --- DCT JPEG (libjpeg-turbo) ---
+check("8bit jpeg400jfif.raw         <- JPEG decoder (SOF0 + DRI)", decodeSequentialDCT(F("libjpeg-turbo-8bit/test/fixtures/jpeg/jpeg400jfif.jpg")).bytes, F("libjpeg-turbo-8bit/test/fixtures/raw/jpeg400jfif.raw"));
+check("12bit CT-512x512-12bit.raw   <- JPEG decoder (SOF1, 12-bit)", decodeSequentialDCT(F("libjpeg-turbo-12bit/test/fixtures/jpeg/CT-512x512-12bit.jpg")).bytes, F("libjpeg-turbo-12bit/test/fixtures/raw/CT-512x512-12bit.raw"));
+
+const width = Math.max(...results.map(([n]) => n.length));
+for (const [n, r] of results) console.log(n.padEnd(width + 2) + r);
+const bad = results.filter(([, r]) => r !== "BYTE-EXACT").length;
+console.log(`\n${results.length - bad}/${results.length} checks byte-exact${bad ? ` - ${bad} FAILED` : ""}`);
+process.exit(bad ? 1 : 0);
diff --git a/yarn.lock b/yarn.lock
index 6503e62..c7eeb6a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -964,27 +964,28 @@
     "@babel/helper-string-parser" "^7.27.1"
     "@babel/helper-validator-identifier" "^7.28.5"
 
-"@bcoe/v8-coverage@^0.2.3":
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39"
-  integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==
+"@bcoe/v8-coverage@^1.0.2":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz#bbe12dca5b4ef983a0d0af4b07b9bc90ea0ababa"
+  integrity sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==
 
-"@codspeed/core@^4.0.1":
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/@codspeed/core/-/core-4.0.1.tgz#91049cce17b8c1d1b4b6cbc481f5ddc1145d6e1e"
-  integrity sha512-fJ53arfgtzCDZa8DuGJhpTZ3Ll9A1uW5nQ2jSJnfO4Hl5MRD2cP8P4vPvIUAGbdbjwCxR1jat6cW8OloMJkJXw==
+"@codspeed/core@^5.7.1":
+  version "5.7.1"
+  resolved "https://registry.yarnpkg.com/@codspeed/core/-/core-5.7.1.tgz#d242510013f540cbb55109c44eb5f837796e2213"
+  integrity sha512-7mrFkqaY14rXu3XHv3o7bK3btLK0LFRxfeK3bQC8dLduI/Ty9eq8Hv8rx04FAY/onQbRTx3rUUQg5xprYHpATQ==
   dependencies:
     axios "^1.4.0"
     find-up "^6.3.0"
-    form-data "^4.0.0"
+    form-data "^4.0.4"
     node-gyp-build "^4.6.0"
+    stack-trace "1.0.0-pre2"
 
-"@codspeed/vitest-plugin@^4.0.1":
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/@codspeed/vitest-plugin/-/vitest-plugin-4.0.1.tgz#b102747e423b3c64cb1f81570939d44f56b280ce"
-  integrity sha512-aqmrPJzX9cD50UWDsOyih5L5WcEYlNQg3u84sJJ9ZuuLApA51w+LGxk6Xbyb8LJF9n/CwM94HKHV/qArfnvDoQ==
+"@codspeed/vitest-plugin@^5.7.1":
+  version "5.7.1"
+  resolved "https://registry.yarnpkg.com/@codspeed/vitest-plugin/-/vitest-plugin-5.7.1.tgz#148e47a841e56617fc73d938a1b634286ba68caf"
+  integrity sha512-yKNqaYVxZZPJYkhVHpz30Oem4TUgcI+/IRDD9YHvcAgi0P42CL6TB/+qYjuFOWghFzTPrm3TUbNFoBsevSTbUA==
   dependencies:
-    "@codspeed/core" "^4.0.1"
+    "@codspeed/core" "^5.7.1"
 
 "@discoveryjs/json-ext@^0.5.0":
   version "0.5.7"
@@ -1013,120 +1014,135 @@
   dependencies:
     tslib "^2.4.0"
 
-"@esbuild/aix-ppc64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz#c7184a326533fcdf1b8ee0733e21c713b975575f"
-  integrity sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==
-
-"@esbuild/android-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz#09d9b4357780da9ea3a7dfb833a1f1ff439b4052"
-  integrity sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==
-
-"@esbuild/android-arm@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz#9b04384fb771926dfa6d7ad04324ecb2ab9b2e28"
-  integrity sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==
-
-"@esbuild/android-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz#29918ec2db754cedcb6c1b04de8cd6547af6461e"
-  integrity sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==
-
-"@esbuild/darwin-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz#e495b539660e51690f3928af50a76fb0a6ccff2a"
-  integrity sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==
-
-"@esbuild/darwin-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz#c13838fa57372839abdddc91d71542ceea2e1e22"
-  integrity sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==
-
-"@esbuild/freebsd-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz#646b989aa20bf89fd071dd5dbfad69a3542e550e"
-  integrity sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==
-
-"@esbuild/freebsd-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz#aa615cfc80af954d3458906e38ca22c18cf5c261"
-  integrity sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==
-
-"@esbuild/linux-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz#70ac6fa14f5cb7e1f7f887bcffb680ad09922b5b"
-  integrity sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==
-
-"@esbuild/linux-arm@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz#fc6fd11a8aca56c1f6f3894f2bea0479f8f626b9"
-  integrity sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==
-
-"@esbuild/linux-ia32@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz#3271f53b3f93e3d093d518d1649d6d68d346ede2"
-  integrity sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==
-
-"@esbuild/linux-loong64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz#ed62e04238c57026aea831c5a130b73c0f9f26df"
-  integrity sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==
-
-"@esbuild/linux-mips64el@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz#e79b8eb48bf3b106fadec1ac8240fb97b4e64cbe"
-  integrity sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==
-
-"@esbuild/linux-ppc64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz#5f2203860a143b9919d383ef7573521fb154c3e4"
-  integrity sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==
-
-"@esbuild/linux-riscv64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz#07bcafd99322d5af62f618cb9e6a9b7f4bb825dc"
-  integrity sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==
-
-"@esbuild/linux-s390x@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz#b7ccf686751d6a3e44b8627ababc8be3ef62d8de"
-  integrity sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==
-
-"@esbuild/linux-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz#6d8f0c768e070e64309af8004bb94e68ab2bb3b0"
-  integrity sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==
-
-"@esbuild/netbsd-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz#bbe430f60d378ecb88decb219c602667387a6047"
-  integrity sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==
-
-"@esbuild/openbsd-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz#99d1cf2937279560d2104821f5ccce220cb2af70"
-  integrity sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==
-
-"@esbuild/sunos-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz#08741512c10d529566baba837b4fe052c8f3487b"
-  integrity sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==
-
-"@esbuild/win32-arm64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz#675b7385398411240735016144ab2e99a60fc75d"
-  integrity sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==
-
-"@esbuild/win32-ia32@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz#1bfc3ce98aa6ca9a0969e4d2af72144c59c1193b"
-  integrity sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==
-
-"@esbuild/win32-x64@0.21.5":
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz#acad351d582d157bb145535db2a6ff53dd514b5c"
-  integrity sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==
+"@esbuild/aix-ppc64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz#7a01a8d2ec2fbb2dac78adad09b0fa781e4082be"
+  integrity sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==
+
+"@esbuild/android-arm64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz#b540a27d14e4afd058496a4dbec4d3f414db110a"
+  integrity sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==
+
+"@esbuild/android-arm@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.28.1.tgz#704bd297de6d762de54eabbeafbf55f6756abe2f"
+  integrity sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==
+
+"@esbuild/android-x64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.28.1.tgz#d1cb166d34b0fbf0fe8ab460a5594f24a378701e"
+  integrity sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==
+
+"@esbuild/darwin-arm64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz#1034b26457fc886368fe61bbd09f653f6afa8e54"
+  integrity sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==
+
+"@esbuild/darwin-x64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz#65556a432a1e4d72032d8218c1932fcca1a49772"
+  integrity sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==
+
+"@esbuild/freebsd-arm64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz#2e61e0592f9030d7e3dae18ee25ebc535918aef6"
+  integrity sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==
+
+"@esbuild/freebsd-x64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz#c95ec289959ef8079c4dca817a1e2c4be66b9bd3"
+  integrity sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==
+
+"@esbuild/linux-arm64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz#40b22175dda06182f3ee8141186c5ff304c4a717"
+  integrity sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==
+
+"@esbuild/linux-arm@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz#c09a0f67917592ac0de892a9be4d3814debd2a6c"
+  integrity sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==
+
+"@esbuild/linux-ia32@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz#a580f9c676797833891e519fc7a1337c8afd8db3"
+  integrity sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==
+
+"@esbuild/linux-loong64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz#46452cf321dc7f9e91c2fa780a56bb56e79cd68b"
+  integrity sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==
+
+"@esbuild/linux-mips64el@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz#4211b3184dd6608f53dcb22e39f5d34ee08852c8"
+  integrity sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==
+
+"@esbuild/linux-ppc64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz#697857c2a61cb9b0b6bb6652e40c1dc5e1ca8e5d"
+  integrity sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==
+
+"@esbuild/linux-riscv64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz#d192943eb146a40ac4c6497d0cf7be35b986bf08"
+  integrity sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==
+
+"@esbuild/linux-s390x@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz#acea0356da0e0ebc08f97cf7b9c2e401e1e648dc"
+  integrity sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==
+
+"@esbuild/linux-x64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz#6f0c3ce0cb64c534b70c4c45ecb2c16d34e35dfd"
+  integrity sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==
+
+"@esbuild/netbsd-arm64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz#8bcd77077a0dce3378b574fedb26d2a253b73d36"
+  integrity sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==
+
+"@esbuild/netbsd-x64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz#e7fb2a01e99c830c94e6623cd9fefb4c8fb58347"
+  integrity sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==
+
+"@esbuild/openbsd-arm64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz#c52909372db8b86e2c55e05a8940033b5660a3b2"
+  integrity sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==
+
+"@esbuild/openbsd-x64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz#c427b9be5a64c262ff9a7eb70b5fbbaadf446c6c"
+  integrity sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==
+
+"@esbuild/openharmony-arm64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz#dc9b147baca2e6c4b3c85571741ef4860a489097"
+  integrity sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==
+
+"@esbuild/sunos-x64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz#ce866d12df13c15e4c99f073a3d466f6e0649b3a"
+  integrity sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==
+
+"@esbuild/win32-arm64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz#7468e3692d01d629d5941e5d83817bb80f9e39b4"
+  integrity sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==
+
+"@esbuild/win32-ia32@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz#a5bc0063fb2bcab6d0ed63f2a1537958bc269ec6"
+  integrity sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==
+
+"@esbuild/win32-x64@0.28.1":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz#10064ee44f4347b90c9a02b446bbf80a91632b12"
+  integrity sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==
 
 "@hutson/parse-repository-url@^3.0.0":
   version "3.0.2"
@@ -1215,7 +1231,7 @@
     "@jridgewell/resolve-uri" "^3.1.0"
     "@jridgewell/sourcemap-codec" "^1.4.14"
 
-"@jridgewell/trace-mapping@^0.3.23":
+"@jridgewell/trace-mapping@^0.3.23", "@jridgewell/trace-mapping@^0.3.31":
   version "0.3.31"
   resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz#db15d6781c931f3a251a3dac39501c98a6082fd0"
   integrity sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==
@@ -1646,135 +1662,135 @@
   resolved "https://registry.yarnpkg.com/@pkgjs/parseargs/-/parseargs-0.11.0.tgz#a77ea742fab25775145434eb1d2328cf5013ac33"
   integrity sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==
 
-"@rollup/rollup-android-arm-eabi@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.4.tgz#3a04f01e9f01392bbef5920b94aa3b88794be7ab"
-  integrity sha512-F5QXMSiFebS9hKZj02XhWLLnRpJ3B3AROP0tWbFBSj+6kCbg5m9j5JoHKd4mmSVy5mS/IMQloYgYxCuJC0fxEQ==
-
-"@rollup/rollup-android-arm64@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.4.tgz#e371b653ceabc900790ae73f5548a0fd7cd63a70"
-  integrity sha512-GxxTKApUpzRhof7poWvCJHRF51C67u1R7D6DiluBE8wKU1u5GWE8t+v81JvJYtbawoBFX1hLv5Ei4eVjkWokaw==
-
-"@rollup/rollup-darwin-arm64@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.4.tgz#2a5aa70432e39816d666d79287a7324cfc3b4e72"
-  integrity sha512-tua0TaJxMOB1R0V0RS1jFZ/RpURFDJIOR2A6jWwQeawuFyS4gBW+rntLRaQd0EQ4bd6Vp44Z2rXW+YYDBsj6IA==
-
-"@rollup/rollup-darwin-x64@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.4.tgz#c3b5b49629379cd9cdc5d841bf00ed44ebf393dd"
-  integrity sha512-CSKq7MsP+5PFIcydhAiR1K0UhEI1A2jWXVKHPCBZ151yOutENwvnPocgVHkivu2kviURtCEB6zUQw0vs8RrhMg==
-
-"@rollup/rollup-freebsd-arm64@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.4.tgz#f929d8e0462fae6602fc960beeabd7287d859283"
-  integrity sha512-+O8OkVdyvXMtJEciu2wS/pzm1IxntEEQx3z5TAVy4l32G0etZn+RsA48ARRrFm6Ri8fvqPQfgrvNxSjKAbnd3g==
-
-"@rollup/rollup-freebsd-x64@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.4.tgz#c01cb58031226f95d0900b1ec847f4fb32c6e809"
-  integrity sha512-Iw3oMskH3AfNuhU0MSN7vNbdi4me/NiYo2azqPz/Le16zHSa+3RRmliCMWWQmh4lcndccU40xcJuTYJZxNo/lw==
-
-"@rollup/rollup-linux-arm-gnueabihf@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.4.tgz#f29d890c4858c8e0d3be01677eef4f6a359eed9d"
-  integrity sha512-EIPRXTVQpHyF8WOo219AD2yEltPehLTcTMz2fn6JsatLYSzQf00hj3rulF+yauOlF9/FtM2WpkT/hJh/KJFGhA==
-
-"@rollup/rollup-linux-arm-musleabihf@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.4.tgz#1ebfc8eb9f66136ed2faae5f44995add5ca3c964"
-  integrity sha512-J3Yh9PzzF1Ovah2At+lHiGQdsYgArxBbXv/zHfSyaiFQEqvNv7DcW98pCrmdjCZBrqBiKrKKe2V+aaSGWuBe/w==
-
-"@rollup/rollup-linux-arm64-gnu@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.4.tgz#c1fa823c2c4ce46ba7f61de1a4c3fdadd4fb4e7b"
-  integrity sha512-BFDEZMYfUvLn37ONE1yMBojPxnMlTFsdyNoqncT0qFq1mAfllL+ATMMJd8TeuVMiX84s1KbcxcZbXInmcO2mRg==
-
-"@rollup/rollup-linux-arm64-musl@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.4.tgz#a7f18854d0471b78bda8ea38f0891a4e059b571d"
-  integrity sha512-pc9EYOSlOgdQ2uPl1o9PF6/kLSgaUosia7gOuS8mB69IxJvlclko1MECXysjs5ryez1/5zjYqx3+xYU0TU6R1A==
-
-"@rollup/rollup-linux-loong64-gnu@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.4.tgz#83658a9a4576bcce8cef85b2c78b9b649d2200c4"
-  integrity sha512-NxnomyxYerDh5n4iLrNa+sH+Z+U4BMEE46V2PgQ/hoB909i8gV1M5wPojWg9fk1jWpO3IQnOs20K4wyZuFLEFQ==
-
-"@rollup/rollup-linux-loong64-musl@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.4.tgz#fd2af677ae3417bb58d57ae37dd0d84686e40244"
-  integrity sha512-nbJnQ8a3z1mtmrwImCYhc6BGpThAyYVRQxw9uKSKG4wR6aAYno9sVjJ0zaZcW9BPJX1GbrDPf+SvdWjgTuDmnw==
-
-"@rollup/rollup-linux-ppc64-gnu@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.4.tgz#6481647181c4cf8f1ddbd99f62c84cfc56c1a94a"
-  integrity sha512-2EU6acNrQLd8tYvo/LXW535wupT3m6fo7HKo6lr7ktQoItxTyOL1ZCR/GfGCuXl2vR+zmfI6eRXkSemafv+iVg==
-
-"@rollup/rollup-linux-ppc64-musl@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.4.tgz#18610a1a1550e28a5042ca916f898419540f17f4"
-  integrity sha512-WeBtoMuaMxiiIrO2IYP3xs6GMWkJP2C0EoT8beTLkUPmzV1i/UcOSVw1d5r9KBODtHKilG5yFxsGRnBbK3wJ4A==
-
-"@rollup/rollup-linux-riscv64-gnu@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.4.tgz#597bb80465a2621dbe0de0a41c66394a8a7e9a6e"
-  integrity sha512-FJHFfqpKUI3A10WrWKiFbBZ7yVbGT4q4B5o1qKFFojqpaYoh9LrQgqWCmmcxQzVSXYtyB5bzkXrYzlHTs21MYA==
-
-"@rollup/rollup-linux-riscv64-musl@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.4.tgz#a2a919a9f927ef7f24a60af77e3cb55f1ad59e4d"
-  integrity sha512-mcEl6CUT5IAUmQf1m9FYSmVqCJlpQ8r8eyftFUHG8i9OhY7BkBXSUdnLH5DOf0wCOjcP9v/QO93zpmF1SptCCw==
-
-"@rollup/rollup-linux-s390x-gnu@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.4.tgz#3166f6ceae7df9bbfddf9f36be1937231e13e3c6"
-  integrity sha512-ynt3JxVd2w2buzoKDWIyiV1pJW93xlQic1THVLXilz429oijRpSHivZAgp65KBu+cMcgf1eVVjdnTLvPxgCuoQ==
+"@rollup/rollup-android-arm-eabi@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz#5e9849b661c2229cf967a08dbe2dbbe9e8c991e5"
+  integrity sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==
+
+"@rollup/rollup-android-arm64@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz#5b0699ee5dd484b222c9ed74aff43c91ea8b17f8"
+  integrity sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==
+
+"@rollup/rollup-darwin-arm64@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz#8bc52c9d7a3ce8d0533c351a9c935de781daa06f"
+  integrity sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==
+
+"@rollup/rollup-darwin-x64@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz#ba2ef3e8fb310f0af35588f270cfa5aa96e48764"
+  integrity sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==
+
+"@rollup/rollup-freebsd-arm64@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz#93b10bdbfe8ada226b8bc0c02ef6b7f544474d96"
+  integrity sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==
+
+"@rollup/rollup-freebsd-x64@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz#3e8aa38ef3c9c300946871e3fdbb0c30e0a20f86"
+  integrity sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==
+
+"@rollup/rollup-linux-arm-gnueabihf@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz#1d7994384bb0ad1bc41921b506e1642d4f9d7fc3"
+  integrity sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==
+
+"@rollup/rollup-linux-arm-musleabihf@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz#a6540f47cf844a56b80ca9ff95d2acdfb2cef97b"
+  integrity sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==
+
+"@rollup/rollup-linux-arm64-gnu@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz#404f2045651840cbf48da91ba6d0f490f0bc2cbf"
+  integrity sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==
+
+"@rollup/rollup-linux-arm64-musl@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz#a3404ffddf7b474b48c99b9c893b6247bb765ba5"
+  integrity sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==
+
+"@rollup/rollup-linux-loong64-gnu@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz#e8aac6d549b377945e349882f199b7c8eb75ca38"
+  integrity sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==
+
+"@rollup/rollup-linux-loong64-musl@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz#6e2e44ea50310b3a582078a915e5feb879c820d4"
+  integrity sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==
+
+"@rollup/rollup-linux-ppc64-gnu@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz#6898302da6d77a0537cde64b2b4c6b60659bd110"
+  integrity sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==
+
+"@rollup/rollup-linux-ppc64-musl@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz#333717c95dd5a66bef8f63e7ef8a9fd845fd18d0"
+  integrity sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==
+
+"@rollup/rollup-linux-riscv64-gnu@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz#81bc06ba380352004d01f4826eb7cdccefa05bad"
+  integrity sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==
+
+"@rollup/rollup-linux-riscv64-musl@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz#95a7cd39de21389ad6788a5284eaaa738e29ca4c"
+  integrity sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==
+
+"@rollup/rollup-linux-s390x-gnu@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz#06e6db2ec1bc48b5374c7923ef83c2eb024b2452"
+  integrity sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==
 
 "@rollup/rollup-linux-x64-gnu@4.13.0":
   version "4.13.0"
   resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.13.0.tgz#f672f6508f090fc73f08ba40ff76c20b57424778"
   integrity sha512-yUD/8wMffnTKuiIsl6xU+4IA8UNhQ/f1sAnQebmE/lyQ8abjsVyDkyRkWop0kdMhKMprpNIhPmYlCxgHrPoXoA==
 
-"@rollup/rollup-linux-x64-gnu@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.4.tgz#23c9bf79771d804fb87415eb0767569f273261e5"
-  integrity sha512-Boiz5+MsaROEWDf+GGEwF8VMHGhlUoQMtIPjOgA5fv4osupqTVnJteQNKJwUcnUog2G55jYXH7KZFFiJe0TEzQ==
-
-"@rollup/rollup-linux-x64-musl@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.4.tgz#97941c6b94d67fe25cde0f027c10a19f2d1fdd39"
-  integrity sha512-+qfSY27qIrFfI/Hom04KYFw3GKZSGU4lXus51wsb5EuySfFlWRwjkKWoE9emgRw/ukoT4Udsj4W/+xxG8VbPKg==
-
-"@rollup/rollup-openbsd-x64@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.4.tgz#7aeb7d92e2cd1d399f56daf75c39040b777b6c77"
-  integrity sha512-VpTfOPHgVXEBeeR8hZ2O0F3aSso+JDWqTWmTmzcQKted54IAdUVbxE+j/MVxUsKa8L20HJhv3vUezVPoquqWjA==
-
-"@rollup/rollup-openharmony-arm64@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.4.tgz#925de61ae83bf99aa636e8acea87432e8c0ffaab"
-  integrity sha512-IPOsh5aRYuLv/nkU51X10Bf75Bsf6+gZdx1X+QP5QM6lIJFHHqbHLG0uJn/hWthzo13UAc2umiUorqZy3axoZg==
-
-"@rollup/rollup-win32-arm64-msvc@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.4.tgz#888ab83842721491044c46a7407e1f38f3235bb4"
-  integrity sha512-4QzE9E81OohJ/HKzHhsqU+zcYYojVOXlFMs1DdyMT6qXl/niOH7AVElmmEdUNHHS/oRkc++d5k6Vy85zFs0DEw==
-
-"@rollup/rollup-win32-ia32-msvc@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.4.tgz#fa30ac24e3f0232139d2a47500560a28695764d4"
-  integrity sha512-zTPgT1YuHHcd+Tmx7h8aml0FWFVelV5N54oHow9SLj+GfoDy/huQ+UV396N/C7KpMDMiPspRktzM1/0r1usYEA==
-
-"@rollup/rollup-win32-x64-gnu@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.4.tgz#223e2bc93f86e0707568e1fadb5b537e50c976c7"
-  integrity sha512-DRS4G7mi9lJxqEDezIkKCaUIKCrLUUDCUaCsTPCi/rtqaC6D/jjwslMQyiDU50Ka0JKpeXeRBFBAXwArY52vBw==
-
-"@rollup/rollup-win32-x64-msvc@4.60.4":
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.4.tgz#da4f1676d87e2bdf744291b504b0ab79550c3e61"
-  integrity sha512-QVTUovf40zgTqlFVrKA1uXMVvU2QWEFWfAH8Wdc48IxLvrJMQVMBRjuQyUpzZCDkakImib9eVazbWlC6ksWtJw==
+"@rollup/rollup-linux-x64-gnu@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz#5dc818988285e09e88790c6462def72413df2da3"
+  integrity sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==
+
+"@rollup/rollup-linux-x64-musl@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz#2080f4a93349e9afd34be6fc1a37e01fc8bfc80f"
+  integrity sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==
+
+"@rollup/rollup-openbsd-x64@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz#21d64a8acb66221724b923e51af5333df1af044b"
+  integrity sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==
+
+"@rollup/rollup-openharmony-arm64@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz#8e0fcd9d02141e337b4c5b5cff576cb9a76b1ba0"
+  integrity sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==
+
+"@rollup/rollup-win32-arm64-msvc@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz#bdb4cc4efd58efe808203347f0f5463f0ea16e52"
+  integrity sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==
+
+"@rollup/rollup-win32-ia32-msvc@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz#dbaebde5afd24eae0eefe915d901632e7cb59860"
+  integrity sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==
+
+"@rollup/rollup-win32-x64-gnu@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz#84109e85fea5f8f1353499f96578fdc2a0e8b138"
+  integrity sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==
+
+"@rollup/rollup-win32-x64-msvc@4.62.2":
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz#3671ce3f9b928d5c01f879792d5c0b60ae14d4ad"
+  integrity sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==
 
 "@sigstore/bundle@^2.3.2":
   version "2.3.2"
@@ -1847,6 +1863,19 @@
   dependencies:
     tslib "^2.4.0"
 
+"@types/chai@^5.2.2":
+  version "5.2.3"
+  resolved "https://registry.yarnpkg.com/@types/chai/-/chai-5.2.3.tgz#8e9cd9e1c3581fa6b341a5aed5588eb285be0b4a"
+  integrity sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==
+  dependencies:
+    "@types/deep-eql" "*"
+    assertion-error "^2.0.1"
+
+"@types/deep-eql@*":
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/@types/deep-eql/-/deep-eql-4.0.2.tgz#334311971d3a07121e7eb91b684a605e7eea9cbd"
+  integrity sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==
+
 "@types/eslint-scope@^3.7.3":
   version "3.7.7"
   resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.7.tgz#3108bd5f18b0cdb277c867b3dd449c9ed7079ac5"
@@ -1868,12 +1897,7 @@
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.5.tgz#a6ce3e556e00fd9895dd872dd172ad0d4bd687f4"
   integrity sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==
 
-"@types/estree@1.0.8":
-  version "1.0.8"
-  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.8.tgz#958b91c991b1867ced318bedea0e215ee050726e"
-  integrity sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==
-
-"@types/estree@^1.0.0":
+"@types/estree@1.0.9", "@types/estree@^1.0.0":
   version "1.0.9"
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.9.tgz#cf3f0e876d7bee15a93ab925b82bf570a3904a24"
   integrity sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==
@@ -1961,82 +1985,85 @@
     anymatch "^3.0.0"
     source-map "^0.6.0"
 
-"@vitest/coverage-v8@^2.1.8":
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/@vitest/coverage-v8/-/coverage-v8-2.1.9.tgz#060bebfe3705c1023bdc220e17fdea4bd9e2b24d"
-  integrity sha512-Z2cOr0ksM00MpEfyVE8KXIYPEcBFxdbLSs56L8PO0QQMxt/6bDj45uQfxoc96v05KW3clk7vvgP0qfDit9DmfQ==
+"@vitest/coverage-v8@^3.2.4":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@vitest/coverage-v8/-/coverage-v8-3.2.7.tgz#2e9ce1103445c237aaa420a7f0058125fe4a7854"
+  integrity sha512-NEGWJS2XNu2PfRLQwOO3CTKj1tTETxNBdk454vDxVBhxJYhPaA/eS0nAI0c+1El1P7a60z8+i+ZrQoGESweGKg==
   dependencies:
     "@ampproject/remapping" "^2.3.0"
-    "@bcoe/v8-coverage" "^0.2.3"
-    debug "^4.3.7"
+    "@bcoe/v8-coverage" "^1.0.2"
+    ast-v8-to-istanbul "^0.3.3"
+    debug "^4.4.1"
     istanbul-lib-coverage "^3.2.2"
     istanbul-lib-report "^3.0.1"
     istanbul-lib-source-maps "^5.0.6"
     istanbul-reports "^3.1.7"
-    magic-string "^0.30.12"
+    magic-string "^0.30.17"
     magicast "^0.3.5"
-    std-env "^3.8.0"
+    std-env "^3.9.0"
     test-exclude "^7.0.1"
-    tinyrainbow "^1.2.0"
+    tinyrainbow "^2.0.0"
 
-"@vitest/expect@2.1.9":
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/@vitest/expect/-/expect-2.1.9.tgz#b566ea20d58ea6578d8dc37040d6c1a47ebe5ff8"
-  integrity sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==
+"@vitest/expect@3.2.7":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@vitest/expect/-/expect-3.2.7.tgz#70a34158383d008c3bf5d802e2643317f09df6d8"
+  integrity sha512-E8eBXaKibuvH2pSZErOjdVb5vF4PbKYcrnluBTYxEk1l/VhhwZg1kZQsdtjq+CsF5CFydf2Rdkz7jDHKSisi3w==
   dependencies:
-    "@vitest/spy" "2.1.9"
-    "@vitest/utils" "2.1.9"
-    chai "^5.1.2"
-    tinyrainbow "^1.2.0"
+    "@types/chai" "^5.2.2"
+    "@vitest/spy" "3.2.7"
+    "@vitest/utils" "3.2.7"
+    chai "^5.2.0"
+    tinyrainbow "^2.0.0"
 
-"@vitest/mocker@2.1.9":
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/@vitest/mocker/-/mocker-2.1.9.tgz#36243b27351ca8f4d0bbc4ef91594ffd2dc25ef5"
-  integrity sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==
+"@vitest/mocker@3.2.7":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@vitest/mocker/-/mocker-3.2.7.tgz#331be944cb783c642dd42bd743411aca24ea0466"
+  integrity sha512-Trr0hYO9CM3Wj6ksWHRhK9IZpIY6wTMO5u/MqXurMxT57sWBaOPEtP3Oq60ihZuh5JsiagKfz95OcxdEP6dBrA==
   dependencies:
-    "@vitest/spy" "2.1.9"
+    "@vitest/spy" "3.2.7"
     estree-walker "^3.0.3"
-    magic-string "^0.30.12"
+    magic-string "^0.30.17"
 
-"@vitest/pretty-format@2.1.9", "@vitest/pretty-format@^2.1.9":
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/@vitest/pretty-format/-/pretty-format-2.1.9.tgz#434ff2f7611689f9ce70cd7d567eceb883653fdf"
-  integrity sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==
+"@vitest/pretty-format@3.2.7", "@vitest/pretty-format@^3.2.7":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@vitest/pretty-format/-/pretty-format-3.2.7.tgz#2a7b593f8e007e9d8ef7e7343aa30ec73fdeaf29"
+  integrity sha512-KUHlwqVu0sRlhCdyPdQ/wBoTfRahjUky1MubOmYw9fWfIZy1gNoHpuaaQBPAaMaVYdQYHJLurzj8ECCj5OwTqA==
   dependencies:
-    tinyrainbow "^1.2.0"
+    tinyrainbow "^2.0.0"
 
-"@vitest/runner@2.1.9":
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/@vitest/runner/-/runner-2.1.9.tgz#cc18148d2d797fd1fd5908d1f1851d01459be2f6"
-  integrity sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==
+"@vitest/runner@3.2.7":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@vitest/runner/-/runner-3.2.7.tgz#c0c080228189f1fa6cda40f59be09d746b0aca51"
+  integrity sha512-sB9y4ovltoQP+WaUPwmSxO9WIg9Ig694Di5PalVPsYHklAdE027mehpWF2SQSVq+k6sFgaivbTjTJwZLSHbedA==
   dependencies:
-    "@vitest/utils" "2.1.9"
-    pathe "^1.1.2"
+    "@vitest/utils" "3.2.7"
+    pathe "^2.0.3"
+    strip-literal "^3.0.0"
 
-"@vitest/snapshot@2.1.9":
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/@vitest/snapshot/-/snapshot-2.1.9.tgz#24260b93f798afb102e2dcbd7e61c6dfa118df91"
-  integrity sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==
+"@vitest/snapshot@3.2.7":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@vitest/snapshot/-/snapshot-3.2.7.tgz#a3a7e1950ce99ec4cf02395e20ddca403b6c818e"
+  integrity sha512-7C+MwShwtBSI5Buwoyg3s/iY1eHL9PKAf+O1wVh/TdnjXUtkoL/9YQtre90i4MtNXM6edP1wJ2zOBpfCyhIS7g==
   dependencies:
-    "@vitest/pretty-format" "2.1.9"
-    magic-string "^0.30.12"
-    pathe "^1.1.2"
+    "@vitest/pretty-format" "3.2.7"
+    magic-string "^0.30.17"
+    pathe "^2.0.3"
 
-"@vitest/spy@2.1.9":
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/@vitest/spy/-/spy-2.1.9.tgz#cb28538c5039d09818b8bfa8edb4043c94727c60"
-  integrity sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==
+"@vitest/spy@3.2.7":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@vitest/spy/-/spy-3.2.7.tgz#ca7fbee44019523ca450395d9a2284ce9ece1f31"
+  integrity sha512-Q2eQGI6d2L/hBtZ0qNuKcAGid68XK6cv1xsoaIma6PaJhHPoqcEJhYpXZ/5myCMqkNgtP6UKuBhbc0nHKnrkuQ==
   dependencies:
-    tinyspy "^3.0.2"
+    tinyspy "^4.0.3"
 
-"@vitest/utils@2.1.9":
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/@vitest/utils/-/utils-2.1.9.tgz#4f2486de8a54acf7ecbf2c5c24ad7994a680a6c1"
-  integrity sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==
+"@vitest/utils@3.2.7":
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/@vitest/utils/-/utils-3.2.7.tgz#302c8126211ac4dfea87b3b5085c098d6d22e89e"
+  integrity sha512-x6BDOd7dyo3PFLY3I9/HJ25X/6OurhGXk2/B9gOZNPF7XDVjeBK4k01lQE5uvDpbuheErh91qYuE1E2OEjK3Rw==
   dependencies:
-    "@vitest/pretty-format" "2.1.9"
-    loupe "^3.1.2"
-    tinyrainbow "^1.2.0"
+    "@vitest/pretty-format" "3.2.7"
+    loupe "^3.1.4"
+    tinyrainbow "^2.0.0"
 
 "@webassemblyjs/ast@1.12.1", "@webassemblyjs/ast@^1.12.1":
   version "1.12.1"
@@ -2422,6 +2449,15 @@ assertion-error@^2.0.1:
   resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-2.0.1.tgz#f641a196b335690b1070bf00b6e7593fec190bf7"
   integrity sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==
 
+ast-v8-to-istanbul@^0.3.3:
+  version "0.3.12"
+  resolved "https://registry.yarnpkg.com/ast-v8-to-istanbul/-/ast-v8-to-istanbul-0.3.12.tgz#8eb1b7c86ef8499859be761b17ffd91406c0c36f"
+  integrity sha512-BRRC8VRZY2R4Z4lFIL35MwNXmwVqBityvOIwETtsCSwvjl0IdgFsy9NhdaA6j74nUdtJJlIypeRhpDam19Wq3g==
+  dependencies:
+    "@jridgewell/trace-mapping" "^0.3.31"
+    estree-walker "^3.0.3"
+    js-tokens "^10.0.0"
+
 async@^3.2.6:
   version "3.2.6"
   resolved "https://registry.yarnpkg.com/async/-/async-3.2.6.tgz#1b0728e14929d51b85b449b7f06e27c1145e38ce"
@@ -2670,7 +2706,7 @@ caniuse-lite@^1.0.30001646:
   resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001646.tgz#d472f2882259ba032dd73ee069ff01bfd059b25d"
   integrity sha512-dRg00gudiBDDTmUhClSdv3hqRfpbOnU28IpI1T6PBTLWa+kOj0681C8uML3PifYfREuBrVjDGhL3adYpBT6spw==
 
-chai@^5.1.2:
+chai@^5.2.0:
   version "5.3.3"
   resolved "https://registry.yarnpkg.com/chai/-/chai-5.3.3.tgz#dd3da955e270916a4bd3f625f4b919996ada7e06"
   integrity sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==
@@ -3099,7 +3135,7 @@ debug@4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1:
   dependencies:
     ms "2.1.2"
 
-debug@^4.3.4, debug@^4.3.7:
+debug@^4.3.4, debug@^4.4.1:
   version "4.4.3"
   resolved "https://registry.yarnpkg.com/debug/-/debug-4.4.3.tgz#c6ae432d9bd9662582fce08709b038c58e9e3d6a"
   integrity sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==
@@ -3449,7 +3485,7 @@ es-module-lexer@^1.2.1:
   resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-1.5.4.tgz#a8efec3a3da991e60efa6b633a7cad6ab8d26b78"
   integrity sha512-MVNK56NiMrOwitFB7cqDwq0CQutbw+0BvLshJSse0MUNU+y1FC3bUS/AQg7oUng+/wKrrki7JfmwtVHkVfPLlw==
 
-es-module-lexer@^1.5.4:
+es-module-lexer@^1.7.0:
   version "1.7.0"
   resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-1.7.0.tgz#9159601561880a85f2734560a9099b2c31e5372a"
   integrity sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==
@@ -3496,34 +3532,37 @@ es-to-primitive@^1.2.1:
     is-date-object "^1.0.1"
     is-symbol "^1.0.2"
 
-esbuild@^0.21.3:
-  version "0.21.5"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.21.5.tgz#9ca301b120922959b766360d8ac830da0d02997d"
-  integrity sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==
+"esbuild@^0.27.0 || ^0.28.0":
+  version "0.28.1"
+  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.28.1.tgz#ef45b4634c9c9d97a296aea4114a5f9840f95578"
+  integrity sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==
   optionalDependencies:
-    "@esbuild/aix-ppc64" "0.21.5"
-    "@esbuild/android-arm" "0.21.5"
-    "@esbuild/android-arm64" "0.21.5"
-    "@esbuild/android-x64" "0.21.5"
-    "@esbuild/darwin-arm64" "0.21.5"
-    "@esbuild/darwin-x64" "0.21.5"
-    "@esbuild/freebsd-arm64" "0.21.5"
-    "@esbuild/freebsd-x64" "0.21.5"
-    "@esbuild/linux-arm" "0.21.5"
-    "@esbuild/linux-arm64" "0.21.5"
-    "@esbuild/linux-ia32" "0.21.5"
-    "@esbuild/linux-loong64" "0.21.5"
-    "@esbuild/linux-mips64el" "0.21.5"
-    "@esbuild/linux-ppc64" "0.21.5"
-    "@esbuild/linux-riscv64" "0.21.5"
-    "@esbuild/linux-s390x" "0.21.5"
-    "@esbuild/linux-x64" "0.21.5"
-    "@esbuild/netbsd-x64" "0.21.5"
-    "@esbuild/openbsd-x64" "0.21.5"
-    "@esbuild/sunos-x64" "0.21.5"
-    "@esbuild/win32-arm64" "0.21.5"
-    "@esbuild/win32-ia32" "0.21.5"
-    "@esbuild/win32-x64" "0.21.5"
+    "@esbuild/aix-ppc64" "0.28.1"
+    "@esbuild/android-arm" "0.28.1"
+    "@esbuild/android-arm64" "0.28.1"
+    "@esbuild/android-x64" "0.28.1"
+    "@esbuild/darwin-arm64" "0.28.1"
+    "@esbuild/darwin-x64" "0.28.1"
+    "@esbuild/freebsd-arm64" "0.28.1"
+    "@esbuild/freebsd-x64" "0.28.1"
+    "@esbuild/linux-arm" "0.28.1"
+    "@esbuild/linux-arm64" "0.28.1"
+    "@esbuild/linux-ia32" "0.28.1"
+    "@esbuild/linux-loong64" "0.28.1"
+    "@esbuild/linux-mips64el" "0.28.1"
+    "@esbuild/linux-ppc64" "0.28.1"
+    "@esbuild/linux-riscv64" "0.28.1"
+    "@esbuild/linux-s390x" "0.28.1"
+    "@esbuild/linux-x64" "0.28.1"
+    "@esbuild/netbsd-arm64" "0.28.1"
+    "@esbuild/netbsd-x64" "0.28.1"
+    "@esbuild/openbsd-arm64" "0.28.1"
+    "@esbuild/openbsd-x64" "0.28.1"
+    "@esbuild/openharmony-arm64" "0.28.1"
+    "@esbuild/sunos-x64" "0.28.1"
+    "@esbuild/win32-arm64" "0.28.1"
+    "@esbuild/win32-ia32" "0.28.1"
+    "@esbuild/win32-x64" "0.28.1"
 
 escalade@^3.1.1:
   version "3.2.0"
@@ -3607,10 +3646,10 @@ execa@5.0.0:
     signal-exit "^3.0.3"
     strip-final-newline "^2.0.0"
 
-expect-type@^1.1.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/expect-type/-/expect-type-1.3.0.tgz#0d58ed361877a31bbc4dd6cf71bbfef7faf6bd68"
-  integrity sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==
+expect-type@^1.2.1:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/expect-type/-/expect-type-1.4.0.tgz#24edf7f0cc69a44d008567ba4594ab96f3c3a3d6"
+  integrity sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==
 
 exponential-backoff@^3.1.1:
   version "3.1.3"
@@ -3632,7 +3671,7 @@ fastest-levenshtein@^1.0.12:
   resolved "https://registry.yarnpkg.com/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz#210e61b6ff181de91ea9b3d1b84fdedd47e034e5"
   integrity sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==
 
-fdir@^6.4.3:
+fdir@^6.4.3, fdir@^6.5.0:
   version "6.5.0"
   resolved "https://registry.yarnpkg.com/fdir/-/fdir-6.5.0.tgz#ed2ab967a331ade62f18d077dae192684d50d350"
   integrity sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==
@@ -3713,10 +3752,10 @@ foreground-child@^3.1.0:
     cross-spawn "^7.0.6"
     signal-exit "^4.0.1"
 
-form-data@^4.0.0, form-data@^4.0.5:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.5.tgz#b49e48858045ff4cbf6b03e1805cebcad3679053"
-  integrity sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==
+form-data@^4.0.4:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.4.tgz#784cdcce0669a9d68e94d11ac4eea98088edd2c4"
+  integrity sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==
   dependencies:
     asynckit "^0.4.0"
     combined-stream "^1.0.8"
@@ -3724,10 +3763,10 @@ form-data@^4.0.0, form-data@^4.0.5:
     hasown "^2.0.2"
     mime-types "^2.1.12"
 
-form-data@^4.0.4:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.4.tgz#784cdcce0669a9d68e94d11ac4eea98088edd2c4"
-  integrity sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==
+form-data@^4.0.5:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.5.tgz#b49e48858045ff4cbf6b03e1805cebcad3679053"
+  integrity sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==
   dependencies:
     asynckit "^0.4.0"
     combined-stream "^1.0.8"
@@ -4685,11 +4724,21 @@ jpeg-lossless-decoder-js@^2.0.4:
   optionalDependencies:
     "@rollup/rollup-linux-x64-gnu" "4.13.0"
 
+js-tokens@^10.0.0:
+  version "10.0.0"
+  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-10.0.0.tgz#dffe7599b4a8bb7fe30aff8d0235234dffb79831"
+  integrity sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==
+
 js-tokens@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 
+js-tokens@^9.0.1:
+  version "9.0.1"
+  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-9.0.1.tgz#2ec43964658435296f6761b34e10671c2d9527f4"
+  integrity sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==
+
 js-yaml@4.1.0, js-yaml@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
@@ -4996,7 +5045,7 @@ log-symbols@^4.0.0, log-symbols@^4.1.0:
     chalk "^4.1.0"
     is-unicode-supported "^0.1.0"
 
-loupe@^3.1.0, loupe@^3.1.2:
+loupe@^3.1.0, loupe@^3.1.4:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/loupe/-/loupe-3.2.1.tgz#0095cf56dc5b7a9a7c08ff5b1a8796ec8ad17e76"
   integrity sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==
@@ -5027,7 +5076,7 @@ lru-cache@^6.0.0:
   dependencies:
     yallist "^4.0.0"
 
-magic-string@^0.30.12:
+magic-string@^0.30.17:
   version "0.30.21"
   resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.30.21.tgz#56763ec09a0fa8091df27879fd94d19078c00d91"
   integrity sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==
@@ -5890,10 +5939,10 @@ path-type@^3.0.0:
   dependencies:
     pify "^3.0.0"
 
-pathe@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/pathe/-/pathe-1.1.2.tgz#6c4cb47a945692e48a1ddd6e4094d170516437ec"
-  integrity sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==
+pathe@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/pathe/-/pathe-2.0.3.tgz#3ecbec55421685b70a9da872b2cff3e1cbed1716"
+  integrity sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==
 
 pathval@^2.0.0:
   version "2.0.1"
@@ -5920,6 +5969,11 @@ picomatch@^4.0.2:
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-4.0.3.tgz#796c76136d1eead715db1e7bad785dedd695a042"
   integrity sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==
 
+picomatch@^4.0.3, picomatch@^4.0.4:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-4.0.5.tgz#51ea57a17d86f605f81039595fbc40ed06a55fab"
+  integrity sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==
+
 pify@5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/pify/-/pify-5.0.0.tgz#1f5eca3f5e87ebec28cc6d54a0e4aaf00acc127f"
@@ -5959,6 +6013,11 @@ pkg-dir@^4.1.0, pkg-dir@^4.2.0:
   dependencies:
     find-up "^4.0.0"
 
+playwright-core@^1.49.0:
+  version "1.61.1"
+  resolved "https://registry.yarnpkg.com/playwright-core/-/playwright-core-1.61.1.tgz#3c99841307efbbabc9d724c41a88c914705d15fc"
+  integrity sha512-h7Qlt6m4REp25qvIdvbDtVmD4LqVXfpRxhORv9L0jzETM05p4fuPJ3dKyuSXQxDSbXnmS79HAgi9589lGSpLkg==
+
 possible-typed-array-names@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/possible-typed-array-names/-/possible-typed-array-names-1.0.0.tgz#89bb63c6fada2c3e90adc4a647beeeb39cc7bf8f"
@@ -5972,10 +6031,10 @@ postcss-selector-parser@^6.0.10:
     cssesc "^3.0.0"
     util-deprecate "^1.0.2"
 
-postcss@^8.4.43:
-  version "8.5.15"
-  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.5.15.tgz#d1eaf677a324e9ec02196da2d3fecf4a0b9a735c"
-  integrity sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==
+postcss@^8.5.6:
+  version "8.5.16"
+  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.5.16.tgz#1230ce0b5df354c24c0ea45f99ce5f6a88279d28"
+  integrity sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==
   dependencies:
     nanoid "^3.3.12"
     picocolors "^1.1.1"
@@ -6310,38 +6369,38 @@ rimraf@^4.4.1:
   dependencies:
     glob "^9.2.0"
 
-rollup@^4.20.0:
-  version "4.60.4"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.60.4.tgz#ca3814f5900da3ac3981d2e0c61944b7e6e0cb09"
-  integrity sha512-WHeFSbZYsPu3+bLoNRUuAO+wavNlocOPf3wSHTP7hcFKVnJeWsYlCDbr3mTS14FCizf9ccIxXA8sGL8zKeQN3g==
+rollup@^4.43.0:
+  version "4.62.2"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.62.2.tgz#d90fc4cb811f071303c890b779595634f35f9541"
+  integrity sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==
   dependencies:
-    "@types/estree" "1.0.8"
+    "@types/estree" "1.0.9"
   optionalDependencies:
-    "@rollup/rollup-android-arm-eabi" "4.60.4"
-    "@rollup/rollup-android-arm64" "4.60.4"
-    "@rollup/rollup-darwin-arm64" "4.60.4"
-    "@rollup/rollup-darwin-x64" "4.60.4"
-    "@rollup/rollup-freebsd-arm64" "4.60.4"
-    "@rollup/rollup-freebsd-x64" "4.60.4"
-    "@rollup/rollup-linux-arm-gnueabihf" "4.60.4"
-    "@rollup/rollup-linux-arm-musleabihf" "4.60.4"
-    "@rollup/rollup-linux-arm64-gnu" "4.60.4"
-    "@rollup/rollup-linux-arm64-musl" "4.60.4"
-    "@rollup/rollup-linux-loong64-gnu" "4.60.4"
-    "@rollup/rollup-linux-loong64-musl" "4.60.4"
-    "@rollup/rollup-linux-ppc64-gnu" "4.60.4"
-    "@rollup/rollup-linux-ppc64-musl" "4.60.4"
-    "@rollup/rollup-linux-riscv64-gnu" "4.60.4"
-    "@rollup/rollup-linux-riscv64-musl" "4.60.4"
-    "@rollup/rollup-linux-s390x-gnu" "4.60.4"
-    "@rollup/rollup-linux-x64-gnu" "4.60.4"
-    "@rollup/rollup-linux-x64-musl" "4.60.4"
-    "@rollup/rollup-openbsd-x64" "4.60.4"
-    "@rollup/rollup-openharmony-arm64" "4.60.4"
-    "@rollup/rollup-win32-arm64-msvc" "4.60.4"
-    "@rollup/rollup-win32-ia32-msvc" "4.60.4"
-    "@rollup/rollup-win32-x64-gnu" "4.60.4"
-    "@rollup/rollup-win32-x64-msvc" "4.60.4"
+    "@rollup/rollup-android-arm-eabi" "4.62.2"
+    "@rollup/rollup-android-arm64" "4.62.2"
+    "@rollup/rollup-darwin-arm64" "4.62.2"
+    "@rollup/rollup-darwin-x64" "4.62.2"
+    "@rollup/rollup-freebsd-arm64" "4.62.2"
+    "@rollup/rollup-freebsd-x64" "4.62.2"
+    "@rollup/rollup-linux-arm-gnueabihf" "4.62.2"
+    "@rollup/rollup-linux-arm-musleabihf" "4.62.2"
+    "@rollup/rollup-linux-arm64-gnu" "4.62.2"
+    "@rollup/rollup-linux-arm64-musl" "4.62.2"
+    "@rollup/rollup-linux-loong64-gnu" "4.62.2"
+    "@rollup/rollup-linux-loong64-musl" "4.62.2"
+    "@rollup/rollup-linux-ppc64-gnu" "4.62.2"
+    "@rollup/rollup-linux-ppc64-musl" "4.62.2"
+    "@rollup/rollup-linux-riscv64-gnu" "4.62.2"
+    "@rollup/rollup-linux-riscv64-musl" "4.62.2"
+    "@rollup/rollup-linux-s390x-gnu" "4.62.2"
+    "@rollup/rollup-linux-x64-gnu" "4.62.2"
+    "@rollup/rollup-linux-x64-musl" "4.62.2"
+    "@rollup/rollup-openbsd-x64" "4.62.2"
+    "@rollup/rollup-openharmony-arm64" "4.62.2"
+    "@rollup/rollup-win32-arm64-msvc" "4.62.2"
+    "@rollup/rollup-win32-ia32-msvc" "4.62.2"
+    "@rollup/rollup-win32-x64-gnu" "4.62.2"
+    "@rollup/rollup-win32-x64-msvc" "4.62.2"
     fsevents "~2.3.2"
 
 run-async@^2.4.0:
@@ -6627,12 +6686,17 @@ ssri@^10.0.0, ssri@^10.0.6:
   dependencies:
     minipass "^7.0.3"
 
+stack-trace@1.0.0-pre2:
+  version "1.0.0-pre2"
+  resolved "https://registry.yarnpkg.com/stack-trace/-/stack-trace-1.0.0-pre2.tgz#46a83a79f1b287807e9aaafc6a5dd8bcde626f9c"
+  integrity sha512-2ztBJRek8IVofG9DBJqdy2N5kulaacX30Nz7xmkYF6ale9WBVmIy6mFBchvGX7Vx/MyjBhx+Rcxqrj+dbOnQ6A==
+
 stackback@0.0.2:
   version "0.0.2"
   resolved "https://registry.yarnpkg.com/stackback/-/stackback-0.0.2.tgz#1ac8a0d9483848d1695e418b6d031a3c3ce68e3b"
   integrity sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==
 
-std-env@^3.8.0:
+std-env@^3.9.0:
   version "3.10.0"
   resolved "https://registry.yarnpkg.com/std-env/-/std-env-3.10.0.tgz#d810b27e3a073047b2b5e40034881f5ea6f9c83b"
   integrity sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==
@@ -6756,6 +6820,13 @@ strip-indent@^3.0.0:
   dependencies:
     min-indent "^1.0.0"
 
+strip-literal@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/strip-literal/-/strip-literal-3.1.0.tgz#222b243dd2d49c0bcd0de8906adbd84177196032"
+  integrity sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==
+  dependencies:
+    js-tokens "^9.0.1"
+
 supports-color@^5.3.0:
   version "5.5.0"
   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
@@ -6882,7 +6953,7 @@ tinybench@^2.9.0:
   resolved "https://registry.yarnpkg.com/tinybench/-/tinybench-2.9.0.tgz#103c9f8ba6d7237a47ab6dd1dcff77251863426b"
   integrity sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==
 
-tinyexec@^0.3.1:
+tinyexec@^0.3.2:
   version "0.3.2"
   resolved "https://registry.yarnpkg.com/tinyexec/-/tinyexec-0.3.2.tgz#941794e657a85e496577995c6eef66f53f42b3d2"
   integrity sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==
@@ -6895,20 +6966,28 @@ tinyglobby@0.2.12:
     fdir "^6.4.3"
     picomatch "^4.0.2"
 
-tinypool@^1.0.1:
+tinyglobby@^0.2.14, tinyglobby@^0.2.15:
+  version "0.2.17"
+  resolved "https://registry.yarnpkg.com/tinyglobby/-/tinyglobby-0.2.17.tgz#562a9a6c9eb2b3b123d39719f9af5bb44fcd7631"
+  integrity sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==
+  dependencies:
+    fdir "^6.5.0"
+    picomatch "^4.0.4"
+
+tinypool@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/tinypool/-/tinypool-1.1.1.tgz#059f2d042bd37567fbc017d3d426bdd2a2612591"
   integrity sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==
 
-tinyrainbow@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/tinyrainbow/-/tinyrainbow-1.2.0.tgz#5c57d2fc0fb3d1afd78465c33ca885d04f02abb5"
-  integrity sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==
+tinyrainbow@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/tinyrainbow/-/tinyrainbow-2.0.0.tgz#9509b2162436315e80e3eee0fcce4474d2444294"
+  integrity sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==
 
-tinyspy@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/tinyspy/-/tinyspy-3.0.2.tgz#86dd3cf3d737b15adcf17d7887c84a75201df20a"
-  integrity sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==
+tinyspy@^4.0.3:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/tinyspy/-/tinyspy-4.0.4.tgz#d77a002fb53a88aa1429b419c1c92492e0c81f78"
+  integrity sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==
 
 tmp@~0.2.1:
   version "0.2.5"
@@ -7165,52 +7244,58 @@ validate-npm-package-name@5.0.1, validate-npm-package-name@^5.0.0:
   resolved "https://registry.yarnpkg.com/validate-npm-package-name/-/validate-npm-package-name-5.0.1.tgz#a316573e9b49f3ccd90dbb6eb52b3f06c6d604e8"
   integrity sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==
 
-vite-node@2.1.9:
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/vite-node/-/vite-node-2.1.9.tgz#549710f76a643f1c39ef34bdb5493a944e4f895f"
-  integrity sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==
+vite-node@3.2.4:
+  version "3.2.4"
+  resolved "https://registry.yarnpkg.com/vite-node/-/vite-node-3.2.4.tgz#f3676d94c4af1e76898c162c92728bca65f7bb07"
+  integrity sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==
   dependencies:
     cac "^6.7.14"
-    debug "^4.3.7"
-    es-module-lexer "^1.5.4"
-    pathe "^1.1.2"
-    vite "^5.0.0"
-
-vite@^5.0.0:
-  version "5.4.21"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-5.4.21.tgz#84a4f7c5d860b071676d39ba513c0d598fdc7027"
-  integrity sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==
-  dependencies:
-    esbuild "^0.21.3"
-    postcss "^8.4.43"
-    rollup "^4.20.0"
+    debug "^4.4.1"
+    es-module-lexer "^1.7.0"
+    pathe "^2.0.3"
+    vite "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+
+"vite@^5.0.0 || ^6.0.0 || ^7.0.0-0":
+  version "7.3.6"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-7.3.6.tgz#0547a395e68d3746e9a505f1fd4469fe09b49cc4"
+  integrity sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==
+  dependencies:
+    esbuild "^0.27.0 || ^0.28.0"
+    fdir "^6.5.0"
+    picomatch "^4.0.3"
+    postcss "^8.5.6"
+    rollup "^4.43.0"
+    tinyglobby "^0.2.15"
   optionalDependencies:
     fsevents "~2.3.3"
 
-vitest@^2.1.8:
-  version "2.1.9"
-  resolved "https://registry.yarnpkg.com/vitest/-/vitest-2.1.9.tgz#7d01ffd07a553a51c87170b5e80fea3da7fb41e7"
-  integrity sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==
-  dependencies:
-    "@vitest/expect" "2.1.9"
-    "@vitest/mocker" "2.1.9"
-    "@vitest/pretty-format" "^2.1.9"
-    "@vitest/runner" "2.1.9"
-    "@vitest/snapshot" "2.1.9"
-    "@vitest/spy" "2.1.9"
-    "@vitest/utils" "2.1.9"
-    chai "^5.1.2"
-    debug "^4.3.7"
-    expect-type "^1.1.0"
-    magic-string "^0.30.12"
-    pathe "^1.1.2"
-    std-env "^3.8.0"
+vitest@^3.2.4:
+  version "3.2.7"
+  resolved "https://registry.yarnpkg.com/vitest/-/vitest-3.2.7.tgz#1944b6ed013a25fd26a73d18e1af92c10a57af6c"
+  integrity sha512-KrxIJ62Fd89gfysR4WotlgZABiz2dqFPgqGzX7s+CwsqLFomRH7777ZcrOD6+WVAh7khPQP41A+BKbpcJFrdEg==
+  dependencies:
+    "@types/chai" "^5.2.2"
+    "@vitest/expect" "3.2.7"
+    "@vitest/mocker" "3.2.7"
+    "@vitest/pretty-format" "^3.2.7"
+    "@vitest/runner" "3.2.7"
+    "@vitest/snapshot" "3.2.7"
+    "@vitest/spy" "3.2.7"
+    "@vitest/utils" "3.2.7"
+    chai "^5.2.0"
+    debug "^4.4.1"
+    expect-type "^1.2.1"
+    magic-string "^0.30.17"
+    pathe "^2.0.3"
+    picomatch "^4.0.2"
+    std-env "^3.9.0"
     tinybench "^2.9.0"
-    tinyexec "^0.3.1"
-    tinypool "^1.0.1"
-    tinyrainbow "^1.2.0"
-    vite "^5.0.0"
-    vite-node "2.1.9"
+    tinyexec "^0.3.2"
+    tinyglobby "^0.2.14"
+    tinypool "^1.1.1"
+    tinyrainbow "^2.0.0"
+    vite "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+    vite-node "3.2.4"
     why-is-node-running "^2.3.0"
 
 walk-up-path@^3.0.1: